mps 0.5.0 → 1.0.1

data/lib/mps/cli/commands/git.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+MPS::CLI::MPS.class_eval do
+  desc "git GITCOMMAND", "Run git commands inside storage_dir"
+  def git(*commands)
+    init
+    begin
+      git_command = if commands.first == "auto"
+        auto_git_cmd
+      elsif commands.first == "autocommit"
+        "git add . && git commit -m \"$(date)\""
+      elsif commands.size > 0
+        cmds = commands.map { |c| c.include?(" ") ? "\"#{c}\"" : c }
+        "git #{cmds.join(' ')}"
+      else
+        "git status"
+      end
+      inside(@config.storage_dir) { run git_command }
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+
+  desc "autogit", "Auto stage, commit, pull and push"
+  def autogit
+    init
+    begin
+      inside(@config.storage_dir) { run auto_git_cmd }
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+
+  desc "cmd COMMAND", "Run shell commands inside storage_dir"
+  def cmd(*commands)
+    init
+    begin
+      cmds = commands.map { |c| c.include?(" ") ? "\"#{c}\"" : c }
+      inside(@config.storage_dir) { run cmds.join(" ") }
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+end

data/lib/mps/cli/commands/list.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+MPS::CLI::MPS.class_eval do
+  desc "list [DATESIGN]", "List elements for a date (default: today)"
+  method_option :type,           type: :string,  aliases: "-t",
+                                 desc: "Filter by type: task, note, log, reminder"
+  method_option :tag,            type: :string,  aliases: "-g", desc: "Filter by tag"
+  method_option :status,         type: :string,  aliases: "-s",
+                                 desc: "Filter tasks by status: open, done"
+  method_option :since,          type: :string,  aliases: "-S",
+                                 desc: "Show elements from SINCE up to DATESIGN"
+  method_option :refs,           type: :boolean, aliases: "-r", default: false,
+                                 desc: "Show human-readable ref column"
+  method_option :all,            type: :boolean, aliases: "-a", default: false,
+                                 desc: "List elements across all dates"
+  method_option :per_line_space, type: :numeric, default: 0,
+                                 desc: "Blank lines after each element (default: 0)"
+  method_option :per_date_space, type: :numeric, default: 0,
+                                 desc: "Blank lines after each date block"
+  def list(datesign = "today")
+    init
+    begin
+      all_dates = store.all_files
+                       .map { |f| Date.strptime(File.basename(f)[0, 8], "%Y%m%d") }
+                       .uniq.sort
+      dates = if options[:all] && options[:since]
+        since_date = ::MPS.get_date(options[:since]).to_date
+        all_dates.select { |d| d >= since_date }
+      elsif options[:all]
+        all_dates
+      elsif options[:since]
+        date_range(options[:since], ::MPS.get_date(datesign))
+      else
+        [::MPS.get_date(datesign).to_date]
+      end
+
+      per_line  = options[:per_line_space].to_i
+      per_date  = options[:per_date_space].to_i
+      shown     = 0
+      multi     = dates.size > 1
+
+      dates.each_with_index do |d, idx|
+        all = store.parse_date(d)
+        next if all.empty?
+        resolver = options[:refs] ? ::MPS::RefResolver.new(all) : nil
+        count = print_tree(all, options, resolver: resolver, per_line_space: per_line,
+                           header: multi ? d.strftime("%Y-%m-%d") : nil)
+        shown += count
+        per_date.times { say "" } if multi && count > 0 && idx < dates.size - 1
+      end
+      say set_color("(no elements found)", :yellow) if shown.zero?
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+end

data/lib/mps/cli/commands/open.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+MPS::CLI::MPS.class_eval do
+  desc "open [DATESIGN]", "Open .mps file in editor (default: today)"
+  def open(datesign = "today")
+    init
+    begin
+      date  = ::MPS.get_date(datesign)
+      files = store.find_files(date)
+      file_path = if files.size > 1
+        ::CLI::UI::Prompt.ask("#{files.size} files found:") do |h|
+          files.each { |f| h.option(File.basename(f)) { |_| f } }
+        end
+      else
+        store.find_or_create_path(date)
+      end
+      @config.logger.info("Open MPS in text editor\n")
+      written = ::MPS.open_editor(file_path)
+      @config.logger.info("Done written Size: #{written} bytes\n")
+      say_status :written, "#{written} bytes", :green
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+end

data/lib/mps/cli/commands/search.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+MPS::CLI::MPS.class_eval do
+  desc "search QUERY", "Full-text search across all .mps files"
+  method_option :type,  type: :string, aliases: "-t", desc: "Filter by type"
+  method_option :tag,   type: :string, aliases: "-g", desc: "Filter by tag"
+  method_option :since, type: :string, aliases: "-S", desc: "Search from this date onward"
+  def search(query)
+    init
+    begin
+      since_date = options[:since] ? ::MPS.get_date(options[:since]).to_date : nil
+      results    = store.search(
+        query,
+        type_filter: options[:type]&.downcase,
+        tag_filter:  options[:tag],
+        since_date:  since_date
+      )
+      if results.empty?
+        say set_color("No results for '#{query}'", :yellow)
+        return
+      end
+      results.each do |r|
+        el       = r[:element]
+        tags_str = el.tags.empty? ? "" : " #{set_color("[#{el.tags.join(', ')}]", :white)}"
+        body_line = el.body_str.strip.lines.first&.strip
+        say "#{set_color(r[:date_str], :white)} #{type_badge(el.class::SIGNATURE_STAMP)} " \
+            "#{element_extra(el)}#{body_line}#{tags_str}"
+      end
+      say set_color("(#{results.size} result#{results.size == 1 ? '' : 's'})", :white)
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+end

data/lib/mps/cli/commands/stats.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+MPS::CLI::MPS.class_eval do
+  desc "stats [DATESIGN]", "Show element counts and log durations"
+  method_option :since,  type: :string,  aliases: "-S", desc: "Stats from SINCE up to DATESIGN"
+  method_option :all,    type: :boolean, aliases: "-a", default: false,
+                         desc: "Stats across all dates"
+  def stats(datesign = "today")
+    init
+    begin
+      dates = if options[:all] && options[:since]
+        since_date = ::MPS.get_date(options[:since]).to_date
+        store.all_files.map { |f| Date.strptime(File.basename(f)[0, 8], "%Y%m%d") }
+             .uniq.sort.select { |d| d >= since_date }
+      elsif options[:all]
+        store.all_files.map { |f| Date.strptime(File.basename(f)[0, 8], "%Y%m%d") }.uniq.sort
+      elsif options[:since]
+        date  = ::MPS.get_date(datesign)
+        date_range(options[:since], date)
+      else
+        date  = ::MPS.get_date(datesign)
+        [date.to_date]
+      end
+
+      total          = Hash.new(0)
+      total_log_mins = 0
+      any            = false
+
+      dates.each do |d|
+        elements = store.parse_date(d).values
+                        .reject { |e| e.is_a?(::MPS::Elements::MPS) || e.is_a?(::MPS::Engines::Parser::Unknown) }
+        next if elements.empty?
+        any    = true
+        counts = elements.group_by { |e| e.class::SIGNATURE_STAMP }.transform_values(&:size)
+        log_mins = elements.select { |e| e.is_a?(::MPS::Elements::Log) }
+                           .sum { |e| e.duration_minutes || 0 }
+        tasks    = elements.select { |e| e.is_a?(::MPS::Elements::Task) }
+
+        parts = []
+        if (n = counts["task"])
+          open_n = tasks.count(&:open?)
+          done_n = tasks.count(&:done?)
+          parts << "#{n} task#{n != 1 ? 's' : ''} " \
+                   "(#{set_color("#{open_n} open", :yellow)}, " \
+                   "#{set_color("#{done_n} done", :green)})"
+        end
+        parts << "#{counts['note']} note#{counts['note'] != 1 ? 's' : ''}"               if counts["note"]
+        parts << "#{counts['reminder']} reminder#{counts['reminder'] != 1 ? 's' : ''}"   if counts["reminder"]
+        if (n = counts["log"])
+          dur_str = format_duration(log_mins)
+          parts << "#{n} log#{n != 1 ? 's' : ''}#{dur_str.empty? ? '' : " (#{dur_str})"}"
+        end
+
+        say "#{set_color(d.strftime('%Y-%m-%d'), :white)} — #{parts.join(', ')}"
+        counts.each { |k, v| total[k] += v }
+        total_log_mins += log_mins
+      end
+
+      say set_color("(no data found)", :yellow) unless any
+
+      if dates.size > 1 && any
+        say set_color("─" * 44, :white)
+        tparts = []
+        tparts << "#{total['task']} tasks"         if total["task"] > 0
+        tparts << "#{total['note']} notes"         if total["note"] > 0
+        tparts << "#{total['reminder']} reminders" if total["reminder"] > 0
+        if total["log"] > 0
+          dur_str = format_duration(total_log_mins)
+          tparts << "#{total['log']} logs#{dur_str.empty? ? '' : " (#{dur_str} total)"}"
+        end
+        say "Total: #{tparts.join(', ')}"
+      end
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+end

data/lib/mps/cli/commands/tags.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+MPS::CLI::MPS.class_eval do
+  desc "tags [DATESIGN]", "Show tag usage table with frequency bars"
+  method_option :type,   type: :string,  aliases: "-t", desc: "Filter by element type"
+  method_option :since,  type: :string,  aliases: "-S", desc: "From SINCE up to DATESIGN"
+  method_option :status, type: :string,  aliases: "-s", desc: "Filter tasks by status"
+  method_option :all,    type: :boolean, aliases: "-a", default: false,
+                         desc: "Count tags across all dates"
+  def tags(datesign = "today")
+    init
+    begin
+      dates = if options[:all] && options[:since]
+        since_date = ::MPS.get_date(options[:since]).to_date
+        store.all_files.map { |f| Date.strptime(File.basename(f)[0, 8], "%Y%m%d") }
+             .uniq.sort.select { |d| d >= since_date }
+      elsif options[:all]
+        store.all_files.map { |f| Date.strptime(File.basename(f)[0, 8], "%Y%m%d") }.uniq.sort
+      elsif options[:since]
+        date_range(options[:since], ::MPS.get_date(datesign))
+      else
+        [::MPS.get_date(datesign).to_date]
+      end
+
+      q      = ::MPS::Query.new(options)
+      counts = Hash.new(0)
+      dates.each do |d|
+        q.apply(store.parse_date(d)).each_value do |el|
+          el.tags.each { |t| counts[t] += 1 }
+        end
+      end
+
+      if counts.empty?
+        say set_color("(no tags found)", :yellow)
+        return
+      end
+
+      sorted  = counts.sort_by { |_, v| -v }
+      max_cnt = sorted.first[1]
+      max_tag = sorted.map(&:first).map(&:length).max
+      bar_max = 24
+
+      say set_color("  #{"Tag".ljust(max_tag)}  Count  Frequency", :white)
+      say set_color("  #{"-" * max_tag}  -----  #{"-" * bar_max}", :white)
+      sorted.each do |tag, n|
+        bar_len = (n.to_f / max_cnt * bar_max).ceil
+        bar     = set_color("█" * bar_len, :cyan)
+        say "  #{set_color(tag.ljust(max_tag), :white)}  #{n.to_s.rjust(5)}  #{bar}"
+      end
+      total = counts.values.sum
+      say ""
+      say set_color("  #{sorted.size} tag#{sorted.size == 1 ? '' : 's'}, #{total} total uses", :white)
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+end

data/lib/mps/cli/commands/update.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+MPS::CLI::MPS.class_eval do
+  # Returns all schema-declared attribute definitions across every element type.
+  # Called at class-load time (for method_option registration) and at call time
+  # (inside the update method body). A class method survives both contexts.
+  def self._schema_update_attrs
+    ::MPS::Elements.constants
+      .map    { |k| ::MPS::Elements.const_get(k) }
+      .select { |x| x.class == Class }
+      .flat_map { |klass| klass.schema.to_a }
+      .uniq { |name, _| name }
+      .select { |_, defn| defn[:flag] }
+  end
+
+  desc "update REFPATH", "Update an element's attributes in-place"
+  _schema_update_attrs.each do |_name, defn|
+    method_option defn[:flag], type: :string, desc: "Set #{defn[:flag]}"
+  end
+  method_option :date, type: :string, aliases: "-d",
+                       desc: "Date context for human refs (default: today)"
+  def update(ref_path)
+    init
+    begin
+      date = options[:date] ? ::MPS.get_date(options[:date]).to_date : Date.today
+      new_attrs = {}
+      self.class._schema_update_attrs.each do |name, defn|
+        flag_sym = defn[:flag].tr("-", "_").to_sym
+        new_attrs[name] = options[flag_sym] if options[flag_sym]
+      end
+      raise Thor::Error, "No attributes specified." if new_attrs.empty?
+
+      unless store.rewrite_element(ref_path, new_attrs, date: date)
+        raise Thor::Error, "Could not update '#{ref_path}'. Check the ref is correct."
+      end
+      say_status :updated, ref_path, :green
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+
+  desc "done REFPATH", "Mark a task as done (shorthand for update REFPATH --status done)"
+  method_option :date, type: :string, aliases: "-d",
+                       desc: "Date context for human refs (default: today)"
+  def done(ref_path)
+    init
+    begin
+      date = options[:date] ? ::MPS.get_date(options[:date]).to_date : Date.today
+      unless store.rewrite_element(ref_path, { status: "done" }, date: date)
+        raise Thor::Error, "Could not mark '#{ref_path}' as done. Check the ref is correct."
+      end
+      say_status :done, ref_path, :green
+    rescue StandardError => e
+      raise Thor::Error, e
+    end
+  end
+end

data/lib/mps/cli/commands.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Auto-discovers and loads all command files from the commands/ directory.
+# Adding a command = adding a file here; no other changes required.
+Dir[File.join(File.dirname(__FILE__), "commands", "*.rb")].sort.each { |f| require f }

data/lib/mps/config.rb

@@ -12,17 +12,22 @@ module MPS
     class MPSDirectoryNotFound < StandardError;end;
     class MPSStorageDirectoryNotFound < StandardError;end;
 
+    attr_reader :mps_dir
     attr_reader :storage_dir
     attr_reader :logger
     attr_reader :log_file
     attr_reader :git_remote
     attr_reader :git_branch
+    attr_reader :default_command
+    attr_reader :type_aliases
     def initialize(**conf_hash)
-      @mps_dir = conf_hash[:mps_dir]
+      @mps_dir         = conf_hash[:mps_dir]
       @storage_dir = conf_hash[:storage_dir]
       @log_file = conf_hash[:log_file]
-      @git_remote = conf_hash.fetch(:git_remote, "origin")
-      @git_branch = conf_hash.fetch(:git_branch, "master")
+      @git_remote      = conf_hash.fetch(:git_remote, "origin")
+      @git_branch      = conf_hash.fetch(:git_branch, "master")
+      @default_command = conf_hash.fetch(:default_command, "open")
+      @type_aliases    = conf_hash.fetch(:aliases, {})
       @logger = Logger.new(File.open(@log_file, "a+"))
       @logger.formatter = proc do |sev, time, pn, msg|
         time = time.strftime("[%Y-%m-%d %H:%M:%S]")

data/lib/mps/constants.rb

@@ -48,11 +48,13 @@ module MPS
 
     # default conf hash
     DEFAULT_CONF_HASH = {
-      mps_dir: MPS_DIR,
-      storage_dir: MPS_STORAGE_DIR,
-      log_file: MPS_LOG_FILE,
-      git_remote: "origin",
-      git_branch: "master"
+      mps_dir:         MPS_DIR,
+      storage_dir:     MPS_STORAGE_DIR,
+      log_file:        MPS_LOG_FILE,
+      git_remote:      "origin",
+      git_branch:      "master",
+      default_command: "open",
+      aliases:         {}
     }
 
 

data/lib/mps/elements/element.rb

@@ -2,7 +2,46 @@
 
 module MPS
   module Element
-    PADDING = '  '
+    # Called when Element is included in a class. Extends the class with
+    # ClassMethods, enabling the `attribute` schema DSL.
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Declare a typed attribute for this element class.
+      #
+      # @param name [Symbol]  parsed_args key
+      # @param type [Symbol]  :string, :time, :integer (for future coercion)
+      # @param default        value when the attribute is absent from args
+      # @param flag [String]  CLI flag name (without --); nil = not filterable
+      # @param aliases [Array<String>] short CLI aliases for this flag
+      def attribute(name, type: :string, default: nil, flag: nil, aliases: [])
+        _schema[name] = { type: type, default: default, flag: flag, aliases: Array(aliases) }
+      end
+
+      # Internal mutable schema hash.
+      def _schema
+        @_schema ||= {}
+      end
+
+      # Frozen public view of the schema.
+      def schema
+        _schema.dup.freeze
+      end
+
+      # Schema-driven parse_args. Subclasses do NOT need to override this.
+      # Any key: value pair in raw whose key matches a declared attribute name
+      # is extracted; remaining bare words become tags.
+      def parse_args(raw)
+        split = ::MPS::Element.split_args(raw)
+        result = { tags: split[:tags] }
+        _schema.each do |name, defn|
+          result[name] = split[:attrs].fetch(name, defn[:default])
+        end
+        result
+      end
+    end
 
     # Parses "work, release, status: done" → { attrs: { status: "done" }, tags: ["work", "release"] }
     # Parts containing ":" become named attrs; bare words become tags.
@@ -23,8 +62,7 @@ module MPS
       { attrs: attrs, tags: tags }
     end
 
-    attr_accessor :disp_str
-    attr_reader   :body_str, :raw_args, :parsed_args
+    attr_reader :body_str, :raw_args, :parsed_args
 
     def initialize(args:, refs:, body_str:)
       @raw_args    = args.to_s
@@ -37,13 +75,5 @@ module MPS
     def tags
       @parsed_args.fetch(:tags, [])
     end
-
-    def display_str(padding_size = @refs.size - 1)
-      strs = @body_str.strip.lines.map(&:strip)
-      header = strs.first
-      res_strs = [(PADDING * padding_size) + header]
-      strs[1..].each { |str| res_strs << (PADDING * padding_size) + str }
-      res_strs.join("\n")
-    end
   end
 end

data/lib/mps/elements/elements.rb

@@ -1,6 +1,8 @@
-ir "./element"
-ir "./mps"
-ir "./note"
-ir "./task"
-ir "./reminder"
-ir "./log"
+# frozen_string_literal: true
+
+require_relative "element"
+require_relative "mps"
+require_relative "note"
+require_relative "task"
+require_relative "reminder"
+require_relative "log"

data/lib/mps/elements/log.rb

@@ -7,10 +7,8 @@ module MPS
       SIGNATURE_REGEX = /\Alog\z/
       include Element
 
-      def self.parse_args(raw)
-        p = Element.split_args(raw)
-        { tags: p[:tags], start: p[:attrs][:start], end: p[:attrs][:end] }
-      end
+      attribute :start, type: :time, default: nil, flag: "start-time"
+      attribute :end,   type: :time, default: nil, flag: "end-time"
 
       def duration_minutes
         s = parsed_args[:start]

data/lib/mps/elements/mps.rb

@@ -6,10 +6,7 @@ module MPS
       SIGNATURE_STAMP = "mps"
       SIGNATURE_REGEX = /\Amps\z/
       include Element
-
-      def self.parse_args(raw)
-        { tags: Element.split_args(raw)[:tags] }
-      end
+      # MPS is a grouping container; carries only tags.
     end
   end
 end

data/lib/mps/elements/note.rb

@@ -6,10 +6,7 @@ module MPS
       SIGNATURE_STAMP = "note"
       SIGNATURE_REGEX = /\Anote\z/
       include Element
-
-      def self.parse_args(raw)
-        { tags: Element.split_args(raw)[:tags] }
-      end
+      # Notes carry only tags; no typed attributes.
     end
   end
 end

data/lib/mps/elements/reminder.rb

@@ -7,10 +7,7 @@ module MPS
       SIGNATURE_REGEX = /\Areminder\z/
       include Element
 
-      def self.parse_args(raw)
-        p = Element.split_args(raw)
-        { tags: p[:tags], at: p[:attrs][:at] }
-      end
+      attribute :at, type: :string, default: nil, flag: "at"
     end
   end
 end

data/lib/mps/elements/task.rb

@@ -7,10 +7,7 @@ module MPS
       SIGNATURE_REGEX = /\Atask\z/
       include Element
 
-      def self.parse_args(raw)
-        p = Element.split_args(raw)
-        { tags: p[:tags], status: p[:attrs].fetch(:status, "open") }
-      end
+      attribute :status, type: :string, default: "open", flag: "status", aliases: ["-s"]
 
       def done? = parsed_args[:status] == "done"
       def open? = !done?

data/lib/mps/engines/engines.rb

@@ -1 +1,3 @@
-ir "./mps"
+# frozen_string_literal: true
+
+require_relative "mps"

data/lib/mps/engines/mps.rb

@@ -28,17 +28,10 @@ module MPS
         element_classes.find { |ec| str =~ ec::SIGNATURE_REGEX }
       end
 
-      # Peeks ahead in +str_scanner+ for +regex_la+ without consuming input.
-      # Returns the position of the match, or string size if no match.
-      def self.look_ahead_pos(str_scanner, regex_la)
-        return str_scanner.string.size unless str_scanner.scan_until(regex_la)
-        pos = str_scanner.pos
-        str_scanner.unscan
-        pos
-      end
-
       # Parses +mps_file_path+ into a flat hash of ref-path => element instances.
-      def self.parse_mps_file_to_elements_hash(mps_file_path, element_classes)
+      # Applies interpolators to body strings if +interpolator_classes+ are provided.
+      def self.parse_mps_file_to_elements_hash(mps_file_path, element_classes,
+                                               interpolator_classes: [])
         content  = File.read(mps_file_path)
         wrapped  = "@#{::MPS::Elements::MPS::SIGNATURE_STAMP}[]{\n#{content}\n}"
         base_ref = ::MPS::Constants::MPS_FILE_NAME_CLIPPER
@@ -94,9 +87,26 @@ module MPS
           end
         end
 
+        _apply_interpolations(elements, interpolator_classes) unless interpolator_classes.empty?
         elements
       end
 
+      # Apply registered interpolators to the body_str of each element.
+      def self._apply_interpolations(elements, interpolator_classes)
+        return if interpolator_classes.empty?
+        elements.each_value do |el|
+          next unless el.respond_to?(:body_str)
+          body = el.instance_variable_get(:@body_str)
+          next unless body
+          interpolator_classes.each do |ic|
+            obj = ic.new
+            new_body = body.gsub(ic::SIGNATURE_REGEX) { obj.get_str }
+            el.instance_variable_set(:@body_str, new_body) if new_body != body
+            body = new_body
+          end
+        end
+      end
+
       class << self
         alias parse_mps_file_to_elments_hash parse_mps_file_to_elements_hash
       end

data/lib/mps/interpolators/interpolators.rb

@@ -1 +1,3 @@
-ir "./time"
+# frozen_string_literal: true
+
+require_relative "time"

data/lib/mps/mps.rb

@@ -1,32 +1,24 @@
 # frozen_string_literal: true
-# 
 
-def ir(rltv_rb_fp)
-  clf = caller_locations.first
-  f, l = clf.path, clf.lineno
-  rltv_rb_fp = File.expand_path(rltv_rb_fp, File.dirname(f))
-  r = require_relative(rltv_rb_fp)
-  puts("#{f} at #{l} for #{rltv_rb_fp}  #=> #{r}") if ENV["MPS_DEBUG"]=="true"
-end
 module MPS
   def self.get_date(str)
-    return Chronic.parse(str).to_date
+    result = Chronic.parse(str)
+    raise ArgumentError, "Cannot parse date: #{str.inspect}" unless result
+    result.to_date
   end
+
   def self.get_filename_from_date(date)
-    "#{date.strftime('%Y%m%d')}.#{Constants::MPS_EXT}"
+    Constants::MPS_NEW_FILE_NAME_GEN.call(date)
   end
+
   def self.get_filenames_from_date_range(s_date, e_date)
-    (s_date..e_date).collect do |date|
-      MPS.get_filename_from_date(date)
-    end
+    (s_date..e_date).collect { |date| MPS.get_filename_from_date(date) }
   end
+
   def self.open_editor(text_file)
-    init_size = 0
-    init_size = File.size(text_file) if File.exist?(text_file)
+    init_size = File.exist?(text_file) ? File.size(text_file) : 0
     TTY::Editor.open(text_file, command: "vim")
-    curr_size = 0
-    curr_size = File.size(text_file) if File.exist?(text_file)
-    return curr_size-init_size
+    curr_size = File.exist?(text_file) ? File.size(text_file) : 0
+    curr_size - init_size
   end
 end
-