rbnotes 0.4.10 → 0.4.15

data/lib/rbnotes/commands/import.rb

@@ -4,9 +4,12 @@ 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
+  # file.  If birthtime is not available on the system, uses mtime
   # (modification time).
   #
+  # When the option, "-m" (or "--use-mtime") is specified, uses mtime
+  # instead of birthtime.
+  #
   # 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
@@ -25,11 +28,20 @@ module Rbnotes::Commands
     #     execute([PATHNAME], Rbnotes::Conf or Hash) -> nil
 
     def execute(args, conf)
+      @opts = {}
+      parse_opts(args)
+
       file = args.shift
       unless file.nil?
         st = File::Stat.new(file)
-        btime = st.respond_to?(:birthtime) ? st.birthtime : st.mtime
-        stamp = Textrepo::Timestamp.new(btime)
+        time = nil
+        if @opts[:use_mtime]
+          time = st.mtime
+        else
+          time = st.respond_to?(:birthtime) ? st.birthtime : st.mtime
+        end
+
+        stamp = Textrepo::Timestamp.new(time)
         puts "Import [%s] (timestamp [%s]) ..." % [file, stamp]
 
         repo = Textrepo.init(conf)
@@ -72,7 +84,7 @@ module Rbnotes::Commands
           puts "Cannot create a text into the repository with the" \
                " specified file [%s]."  % file
           puts "For, the birthtime [%s] is identical to some notes" \
-               " already exists in the reopsitory." % btime
+               " already exists in the reopsitory." % time
           puts "Change the birthtime of the target file, then retry."
         else
           puts "... Done."
@@ -86,7 +98,7 @@ module Rbnotes::Commands
     def help                    # :nodoc:
       puts <<HELP
 usage:
-    #{Rbnotes::NAME} import FILE
+    #{Rbnotes::NAME} import [-m|--use-mtime] FILE
 
 Imports a existing file which specified by the argument as a note.
 
@@ -95,5 +107,25 @@ If birthtime is not available on the system, use mtime (modification
 time).
 HELP
     end
+
+    # :stopdoc:
+
+    private
+
+    def parse_opts(args)
+      while args.size > 0
+        arg = args.shift
+        case arg
+        when "-m", "--use-mtime"
+          @opts[:use_mtime] = true
+        else
+          args.unshift(arg)
+          break
+        end
+      end
+    end
+
+    # :startdoc:
+
   end
 end

data/lib/rbnotes/commands/list.rb

@@ -24,10 +24,12 @@ module Rbnotes::Commands
     #
     # A keyword must be one of them:
     #
-    # - "today"      (or "to")
-    # - "yeasterday" (or "ye")
-    # - "this_week"  (or "tw")
-    # - "last_week"  (or "lw")
+    #   - "today"      (or "to")
+    #   - "yeasterday" (or "ye")
+    #   - "this_week"  (or "tw")
+    #   - "last_week"  (or "lw")
+    #   - "this_month" (or "tm")
+    #   - "last_month" (or "lm")
     #
     # Here is several examples of timestamp patterns.
     #
@@ -52,38 +54,30 @@ module Rbnotes::Commands
 
     def execute(args, conf)
       @opts = {}
-      while args.size > 0
-        arg = args.shift
-        case arg
-        when "-w", "--week"
-          @opts[:enum_week] = true
-        else
-          args.unshift(arg)
-          break
-        end
-      end
+      parse_opts(args)
 
-      patterns = nil
-      if @opts[:enum_week]
-        arg = args.shift || Textrepo::Timestamp.now[0, 8]
-        case arg.size
-        when "yyyymodd".size, "yyyymoddhhmiss".size, "yyyymoddhhmiss_sfx".size
-          stamp_str = "#{arg}000000"[0, 14]
-          timestamp = Textrepo::Timestamp.parse_s(stamp_str)
-          patterns = Rbnotes.utils.timestamp_patterns_in_week(timestamp)
-        else
-          raise InvalidTimestampPatternError,
-                "cannot convert to a date [%s]" % args.unshift(arg)
-        end
-      else
-        patterns = Rbnotes.utils.expand_keyword_in_args(args)
-      end
+      utils = Rbnotes.utils
+      patterns = utils.read_timestamp_patterns(args, enum_week: @opts[:enum_week])
 
       @repo = Textrepo.init(conf)
-      # newer stamp shoud be above
-      Rbnotes.utils.find_notes(patterns, @repo).each { |timestamp|
-        puts Rbnotes.utils.make_headline(timestamp, @repo.read(timestamp))
-      }
+      notes = utils.find_notes(patterns, @repo)
+      output = []
+      if @opts[:verbose]
+        collect_timestamps_by_date(notes).each { |date, timestamps|
+          output << "#{date} (#{timestamps.size})"
+          timestamps.each { |timestamp|
+            pad = "  "
+            output << utils.make_headline(timestamp,
+                                                  @repo.read(timestamp), pad)
+          }
+        }
+      else
+        notes.each { |timestamp|
+          output << utils.make_headline(timestamp,
+                                                @repo.read(timestamp))
+        }
+      end
+      puts output
     end
 
     def help                    # :nodoc:
@@ -110,6 +104,8 @@ KEYWORD:
     - "yeasterday" (or "ye")
     - "this_week"  (or "tw")
     - "last_week"  (or "lw")
+    - "this_month" (or "tm")
+    - "last_month" (or "lm")
 
 An option "--week" is also acceptable.  It specifies to enumerate all
 days of a week.  Typically, the option is used with a STAMP_PATTERN
@@ -124,5 +120,39 @@ would be as same as the KEYWORD, "this_week" was specified.
 HELP
     end
 
+    # :stopdoc:
+
+    private
+
+    def parse_opts(args)
+      while args.size > 0
+        arg = args.shift
+        case arg
+        when "-w", "--week"
+          @opts[:enum_week] = true
+        when "-v", "--verbose"
+          @opts[:verbose] = true
+        else
+          args.unshift(arg)
+          break
+        end
+      end
+    end
+
+    def collect_timestamps_by_date(timestamps)
+      result = {}
+      timestamps.map { |ts|
+        [ts.strftime("%Y-%m-%d"), ts]
+      }.reduce(result) { |r, pair|
+        date, stamp = pair
+        r[date] ||= []
+        r[date] << stamp
+        r
+      }
+      result
+    end
+
+    # :startdoc:
+
   end
 end

data/lib/rbnotes/commands/pick.rb

@@ -10,18 +10,27 @@ module Rbnotes::Commands
     end
 
     def execute(args, conf)
-      patterns = Rbnotes.utils.expand_keyword_in_args(args)
+      @opts = {}
+      parse_opts(args)
+
+      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 +52,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

@@ -1,52 +1,139 @@
 module Rbnotes::Commands
 
   ##
-  # Shows the content of the note specified by the argument.  The
+  # Shows the content of the notes specified by arguments.  Each
   # argument must be a string which can be converted into
   # Textrepo::Timestamp object.
   #
-  # A string for Timestamp must be:
+  # 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 an argument.
-
+  # 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:
-      "Show the content of a note"
+      "Show the content of notes"
     end
 
     def execute(args, conf)
-      stamp = Rbnotes.utils.read_timestamp(args)
+      @opts = {}
+      parse_opts(args)
 
+      stamps = Rbnotes.utils.read_multiple_timestamps(args)
       repo = Textrepo.init(conf)
-      content = repo.read(stamp)
+
+      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?
-        require 'open3'
-        Open3.pipeline_w(pager) { |stdin|
-          stdin.puts content
-          stdin.close
-        }
+        puts_with_pager(pager, make_output(content))
       else
-        puts content
+        puts make_output(content)
       end
     end
 
     def help                    # :nodoc:
       puts <<HELP
 usage:
-    #{Rbnotes::NAME} show [TIMESTAMP]
+    #{Rbnotes::NAME} show [(-n|--num-of-lines) NUMBER] [TIMESTAMP...]
 
-Show the content of given note.  TIMESTAMP must be a fully qualified
+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
     end
+
+    # :stopdoc:
+
+    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|
+        stdin.puts output
+        stdin.close
+      }
+    end
+
+    require "io/console/size"
+
+    def make_output(content)
+      if content.size <= 1
+        return content.values[0]
+      end
+
+      _, column = IO.console_size
+      output = content.map { |timestamp, text|
+        ary = [make_heading(timestamp, [column, 72].min)]
+        ary.concat(text)
+        ary
+      }
+
+      output = insert_delimiter(output, "")
+      output.flatten
+    end
+
+    def make_heading(timestamp, column)
+      stamp_str = timestamp.to_s
+      length = column - (stamp_str.size + 2)
+      "#{stamp_str} #{Array.new(length, '-').join}"
+    end
+
+    def insert_delimiter(ary, delimiter = "")
+      result = []
+      ary.each { |e|
+        result << e
+        result << delimiter
+      }
+      result.delete_at(-1)
+      result
+    end
+
+    # :startdoc:
+
   end
 end

data/lib/rbnotes/commands/statistics.rb

@@ -0,0 +1,74 @@
+module Rbnotes::Commands
+  ##
+  # Shows statistics.
+
+  class Statistics < Command
+
+    def description             # :nodoc:
+      "Show statistics values"
+    end
+
+    def execute(args, conf)
+      @opts = {}
+      parse_opts(args)
+
+      report = :total
+      if @opts[:yearly]
+        report = :yearly
+      elsif @opts[:monthly]
+        report = :monthly
+      end
+
+      stats = Rbnotes::Statistics.new(conf)
+      case report
+      when :yearly
+        stats.yearly_report
+      when :monthly
+        stats.monthly_report
+      else
+        stats.total_report
+      end
+    end
+
+    def help
+      puts <<HELP
+usage:
+    #{Rbnotes::NAME} statistics ([-y|--yearly]|[-m|--monthly])
+
+option:
+    -y, --yearly  : print yearly report
+    -m, --monthly : print monthly report
+
+Show statistics.
+
+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