rbnotes 0.4.10 → 0.4.15

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,17 +31,26 @@ module Rbnotes
 
     DIRNAME_COMMON_CONF = ".config"
 
-    def initialize(conf_path = nil)   # :nodoc:
-      @conf_path = conf_path || File.join(base_path, FILENAME_CONF)
-
+    def initialize(path = nil)   # :nodoc:
       @conf = {}
-      if FileTest.exist?(@conf_path)
-        yaml_str = File.open(@conf_path, "r") { |f| f.read }
-        @conf = YAML.load(yaml_str)
+
+      unless path.nil?
+        abspath = File.expand_path(path)
+        raise NoConfFileError, path unless FileTest.exist?(abspath)
+        @conf[:path] = abspath
       else
-        @conf.merge(DEFAULT_VALUES)
+        @conf[:path] = default_conf_path
       end
-      self
+
+      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,
@@ -89,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
@@ -97,12 +106,17 @@ module Rbnotes
       else
         path = File.join(user, DIRNAME_COMMON_CONF, DIRNAME_RBNOTES)
       end
-      return path
+      path
+    end
+
+    def default_conf_path
+      File.join(config_home, FILENAME_CONF)
     end
-  end
 
   # :startdoc:
 
+  end
+
   class << self
     ##
     # Gets the instance of Rbnotes::Conf.  An optional argument is to

data/lib/rbnotes/error.rb

@@ -7,12 +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"
+    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:
@@ -75,4 +78,42 @@ module Rbnotes
     end
   end
 
+  ##
+  # An error raised when the specified configuration file does not
+  # exist.
+
+  class NoConfFileError < Error
+    def initialize(filename)
+      super(ErrMsg::NO_CONF_FILE % filename)
+    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/statistics.rb

@@ -0,0 +1,101 @@
+module Rbnotes
+  ##
+  # Calculates statistics of the repository.
+  class Statistics
+    include Enumerable
+
+    def initialize(conf)
+      @repo = Textrepo.init(conf)
+      @values = construct_values(@repo)
+    end
+
+    def total_report
+      puts @repo.entries.size
+    end
+
+    def yearly_report
+      self.each_year { |year, monthly_values|
+        num_of_notes = monthly_values.map { |_mon, values| values.size }.sum
+        puts "#{year}: #{num_of_notes}"
+      }
+    end
+
+    def monthly_report
+      self.each { |year, mon, values|
+        num_of_notes = values.size
+        puts "#{year}/#{mon}: #{num_of_notes}"
+      }
+    end
+
+    def each(&block)
+      if block.nil?
+        @values.map { |year, monthly_values|
+          monthly_values.each { |mon, values|
+            [year, mon, values]
+          }
+        }.to_enum(:each)
+      else
+        @values.each { |year, monthly_values|
+          monthly_values.each { |mon, values|
+            yield [year, mon, values]
+          }
+        }
+      end
+    end
+
+    def years
+      @values.keys
+    end
+
+    def months(year)
+      @values[year] || []
+    end
+
+    def each_year(&block)
+      if block.nil?
+        @values.map { |year, monthly_values|
+          [year, monthly_values]
+        }.to_enum(:each)
+      else
+        @values.each { |year, monthly_values|
+          yield [year, monthly_values]
+        }
+      end
+    end
+
+    private
+
+    def construct_values(repo)
+      values = {}
+      repo.each { |timestamp, text|
+        value = StatisticValue.new(timestamp, text)
+        y = value.year
+        m = value.mon
+        values[y] ||= {}
+        values[y][m] ||= []
+
+        values[y][m] << value
+      }
+      values
+    end
+
+    class StatisticValue
+
+      attr_reader :lines
+
+      def initialize(timestamp, text)
+        @timestamp = timestamp
+        @lines = text.size
+      end
+
+      def year
+        @timestamp[:year]
+      end
+
+      def mon
+        @timestamp[:mon]
+      end
+    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,27 +126,102 @@ 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
 
     ##
-    # Reads an argument from the IO object.  Typically, it is intended
-    # to be used with STDIN.
+    # Generates multiple Textrepo::Timestamp objects from the command
+    # 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_arg(IO) -> String
+    #   read_multiple_timestamps(args) -> [String]
+
+    def read_multiple_timestamps(args)
+      strings = args.size < 1 ? read_multiple_args($stdin) : args
+      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
 
-    def read_arg(io)
-      # assumes the reading line looks like:
-      #
-      #     foo bar baz ...
-      #
-      # then, only the first string is interested
       begin
-        io.gets.split(":")[0].rstrip
-      rescue NoMethodError => _
-        nil
+        date = Date.parse(date_str)
+      rescue Date::Error => _e
+        raise InvalidTimestampPatternAsDateError, arg
       end
+
+      dates_in_week(date).map { |date| timestamp_pattern(date) }
     end
 
     ##
@@ -143,72 +245,53 @@ module Rbnotes
     #   - "yeasterday" (or "ye")
     #   - "this_week"  (or "tw")
     #   - "last_week"  (or "lw")
+    #   - "this_month" (or "tm")
+    #   - "last_month" (or "lm")
     #
     # :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 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
@@ -217,6 +300,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)
@@ -227,20 +311,86 @@ module Rbnotes
       }.flatten.sort{ |a, b| b <=> a }.uniq
     end
 
+    # :stopdoc:
+
+    private
+
     ##
-    # Enumerates all timestamp patterns in a week which contains a
-    # given timestamp as a day of the week.
+    # Reads an argument from the IO object.  Typically, it is intended
+    # to be used with STDIN.
     #
     # :call-seq:
-    #     timestamp_patterns_in_week(timestamp) -> [Array of Strings]
+    #   read_arg(IO) -> String
 
-    def timestamp_patterns_in_week(timestamp)
-      dates_in_week(start_date_in_the_week(timestamp.time)).map { |date| timestamp_pattern(date) }
+    def read_arg(io)
+      read_multiple_args(io)[0]
     end
 
-    # :stopdoc:
+    ##
+    # Reads arguments from the IO object.  Typically, it is intended
+    # to be used with STDIN.
+    #
+    # :call-seq:
+    #   read_multiple_arg(IO) -> [String]
+
+    def read_multiple_args(io)
+      strings = io.readlines
+      strings.map { |str|
+        # assumes the reading line looks like:
+        #
+        #     foo bar baz ...
+        #
+        # then, only the first string is interested
+        begin
+          str.split(":")[0].rstrip
+        rescue NoMethodError => _
+          nil
+        end
+      }.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
+    )
 
-    private
     def search_in_path(name)
       search_paths = ENV["PATH"].split(":")
       found = search_paths.map { |path|
@@ -258,49 +408,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 start_date_in_this_week
-      start_date_in_the_week(Time.now)
+    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_last_week
-      start_date_in_this_week.prev_day(7)
+    def start_date_of_week(date)
+      # week day in monday start calendar
+      date.prev_day((date.wday - 1) % 7)
     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 first_date_of_this_month
+      today = Time.now
+      date(Time.new(today.year, today.mon, 1))
     end
 
-    def wday(time)
-      (time.wday - 1) % 7
+    def dates_in_this_month
+      dates_in_month(first_date_of_this_month)
     end
 
-    def dates_in_week(start_date)
-      dates = [start_date]
-      1.upto(6) { |i| dates << start_date.next_day(i) }
+    def dates_in_last_month
+      dates_in_month(first_date_of_this_month.prev_month)
+    end
+
+    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 = ""