dsu 2.0.8 → 2.1.2

data/lib/dsu/subcommands/edit.rb

@@ -12,50 +12,36 @@ module Dsu
       map %w[t] => :tomorrow
       map %w[y] => :yesterday
 
-      desc 'today, n',
-        'Edits the DSU entries for today.'
-      long_desc <<-LONG_DESC
-       Edits the DSU entries for today.
-      LONG_DESC
+      desc I18n.t('subcommands.edit.date.desc'), I18n.t('subcommands.edit.date.usage')
+      long_desc I18n.t('subcommands.edit.date.long_desc', date_option_description: date_option_description)
+      def date(date)
+        entry_group = Models::EntryGroup.edit(time: Time.parse(date))
+        Views::EntryGroup::Show.new(entry_group: entry_group).render
+      rescue ArgumentError => e
+        puts apply_theme(I18n.t('errors.error', message: e.message), theme_color: color_theme.error)
+        exit 1
+      end
+
+      desc I18n.t('subcommands.edit.today.desc'), I18n.t('subcommands.edit.today.usage')
+      long_desc I18n.t('subcommands.edit.today.long_desc')
       def today
         entry_group = Models::EntryGroup.edit(time: Time.now)
         Views::EntryGroup::Show.new(entry_group: entry_group).render
       end
 
-      desc 'tomorrow, t',
-        'Edits the DSU entries for tomorrow.'
-      long_desc <<-LONG_DESC
-        Edits the DSU entries for tomorrow.
-      LONG_DESC
+      desc I18n.t('subcommands.edit.tomorrow.desc'), I18n.t('subcommands.edit.tomorrow.usage')
+      long_desc I18n.t('subcommands.edit.tomorrow.long_desc')
       def tomorrow
         entry_group = Models::EntryGroup.edit(time: Time.now.tomorrow)
         Views::EntryGroup::Show.new(entry_group: entry_group).render
       end
 
-      desc 'yesterday, y',
-        'Edits the DSU entries for yesterday.'
-      long_desc <<-LONG_DESC
-        Edits the DSU entries for yesterday.
-      LONG_DESC
+      desc I18n.t('subcommands.edit.yesterday.desc'), I18n.t('subcommands.edit.yesterday.usage')
+      long_desc I18n.t('subcommands.edit.yesterday.long_desc')
       def yesterday
         entry_group = Models::EntryGroup.edit(time: Time.now.yesterday)
         Views::EntryGroup::Show.new(entry_group: entry_group).render
       end
-
-      desc 'date, d DATE',
-        'Edits the DSU entries for DATE.'
-      long_desc <<-LONG_DESC
-        Edits the DSU entries for DATE.
-
-        \x5 #{date_option_description}
-      LONG_DESC
-      def date(date)
-        entry_group = Models::EntryGroup.edit(time: Time.parse(date))
-        Views::EntryGroup::Show.new(entry_group: entry_group).render
-      rescue ArgumentError => e
-        puts apply_theme("Error: #{e.message}", theme_color: color_theme.error)
-        exit 1
-      end
     end
   end
 end

data/lib/dsu/subcommands/list.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
+require_relative '../services/entry_group/counter_service'
 require_relative '../support/command_options/dsu_times'
-require_relative '../support/command_options/time_mneumonic'
+require_relative '../support/command_options/time_mnemonic'
 require_relative '../support/time_formatable'
 require_relative '../views/entry_group/shared/no_entries_to_display'
 require_relative '../views/shared/error'
@@ -10,7 +11,7 @@ require_relative 'base_subcommand'
 module Dsu
   module Subcommands
     class List < BaseSubcommand
-      include Support::CommandOptions::TimeMneumonic
+      include Support::CommandOptions::TimeMnemonic
       include Support::TimeFormatable
 
       map %w[d] => :date
@@ -19,57 +20,39 @@ module Dsu
       map %w[t] => :tomorrow
       map %w[y] => :yesterday
 
-      desc 'today, n',
-        'Displays the DSU entries for today'
-      long_desc <<-LONG_DESC
-        Displays the DSU entries for today. This command has no options.
-      LONG_DESC
-      option :include_all, type: :boolean, aliases: '-a', desc: 'Include dates that have no DSU entries'
+      desc I18n.t('subcommands.list.today.desc'), I18n.t('subcommands.list.today.usage')
+      long_desc I18n.t('subcommands.list.today.long_desc')
       def today
         time = Time.now
         times = sorted_dsu_times_for(times: [time.yesterday, time])
         view_list_for(times: times, options: options)
       end
 
-      desc 'tomorrow, t',
-        'Displays the DSU entries for tomorrow'
-      long_desc <<-LONG_DESC
-        Displays the DSU entries for tomorrow. This command has no options.
-      LONG_DESC
-      option :include_all, type: :boolean, aliases: '-a', desc: 'Include dates that have no DSU entries'
+      desc I18n.t('subcommands.list.tomorrow.desc'), I18n.t('subcommands.list.tomorrow.usage')
+      long_desc I18n.t('subcommands.list.tomorrow.long_desc')
       def tomorrow
         time = Time.now
         times = sorted_dsu_times_for(times: [time, time.tomorrow])
         view_list_for(times: times, options: options)
       end
 
-      desc 'yesterday, y',
-        'Displays the DSU entries for yesterday'
-      long_desc <<-LONG_DESC
-        Displays the DSU entries for yesterday. This command has no options.
-      LONG_DESC
-      option :include_all, type: :boolean, aliases: '-a', desc: 'Include dates that have no DSU entries'
+      desc I18n.t('subcommands.list.yesterday.desc'), I18n.t('subcommands.list.yesterday.usage')
+      long_desc I18n.t('subcommands.list.yesterday.long_desc')
       def yesterday
         time = Time.now
         times = sorted_dsu_times_for(times: [time.yesterday, time.yesterday.yesterday])
         view_list_for(times: times, options: options)
       end
 
-      desc 'date, d DATE|MNEUMONIC',
-        'Displays the DSU entries for the DATE or MNEUMONIC provided'
-      long_desc <<-LONG_DESC
-        Displays the DSU entries for the DATE or MNEUMONIC provided.
-
-        #{date_option_description}
-
-        #{mneumonic_option_description}
-      LONG_DESC
-      option :include_all, type: :boolean, aliases: '-a', desc: 'Include dates that have no DSU entries'
-      def date(date_or_mneumonic)
-        time = if time_mneumonic?(date_or_mneumonic)
-          time_from_mneumonic(command_option: date_or_mneumonic)
+      desc I18n.t('subcommands.list.date.desc'), I18n.t('subcommands.list.date.usage')
+      long_desc I18n.t('subcommands.list.date.long_desc',
+        date_option_description: date_option_description,
+        mnemonic_option_description: mnemonic_option_description)
+      def date(date_or_mnemonic)
+        time = if time_mnemonic?(date_or_mnemonic)
+          time_from_mnemonic(command_option: date_or_mnemonic)
         else
-          Time.parse(date_or_mneumonic)
+          Time.parse(date_or_mnemonic)
         end
         times = sorted_dsu_times_for(times: [time, time.yesterday])
         view_list_for(times: times, options: options)
@@ -77,67 +60,13 @@ module Dsu
         Views::Shared::Error.new(messages: e.message).render
       end
 
-      desc 'dates|dd OPTIONS',
-        'Displays the DSU entries for the OPTIONS provided'
-      long_desc <<~LONG_DESC
-        NAME
-
-        $ dsu dates|dd OPTIONS -- will display the DSU entries for the OPTIONS provided.
-
-        SYNOPSIS
-
-        $ dsu dates|dd OPTIONS
-
-        OPTIONS
-
-        -a|--include-all true|false: If true, all DSU dates within the specified range will be displayed. If false, DSU dates between the first and last DSU dates that have NO entries will NOT be displayed.. The default is taken from the dsu configuration setting :include_all, see `dsu config info`.
-
-        -f|--from DATE|MNEMONIC: The DATE or MNEUMONIC that represents the start of the range of DSU dates to display. If a relative mneumonic is used (+/-n, e.g +1, -1, etc.), the date calculated will be relative to the current date (e.g. `<MNEUMONIC>.to_i.days.from_now(Time.now)`).
-
-        -t|--to DATE|MNEMONIC: The DATE or MNEUMONIC that represents the end of the range of DSU dates to display. If a relative mneumonic is used (+/-n, e.g +1, -1, etc.), the date calculated will be relative to the date that resulting from the `--from` option date calculation.
-
-        #{date_option_description}
-
-        #{mneumonic_option_description}
-
-        EXAMPLES
-
-        NOTE: All examples are subject to the `--include-all` option.
-
-        The below will display the DSU entries for the range of dates from 1/1 to 1/4:
-
-        $ dsu list dates --from 1/1 --to +3
-
-        This will display the DSU entries for the range of dates from 1/2 to 1/5:
-
-        $ dsu list dates --from 1/5 --to -3
-
-        This (assuming "today" is 1/10) will display the DSU entries for the last week 1/10 to 1/3:
-
-        $ dsu list dates --from today --to -7
-
-        This (assuming "today" is 5/23) will display the DSU entries for the last week 5/16 to 5/22.
-        This example simply illustrates the fact that you can use relative mneumonics for
-        both `--from` and `--to` options; this doesn't mean you should do so...
-
-        While you can use relative mneumonics for both `--from` and `--to` options,
-        there is always a more intuitive way. The below example basically lists one week
-        of DSU entries back 1 week from yesterday's date:
-
-        $ dsu list dates --from -7 --to +6
-
-        The above can be accomplished MUCH easier by simply using the `yesterday` mneumonic...
-
-        This (assuming "today" is 5/23) will display the DSU entries back 1 week from yesterday's date 5/16 to 5/22:
-
-        $ dsu list dates --from yesterday --to -6
-      LONG_DESC
-      # -f, --from FROM [DATE|MNEMONIC] (e.g. -f, --from 1/1[/yyy]|n|t|y|today|tomorrow|yesterday)
+      desc I18n.t('subcommands.list.dates.desc'), I18n.t('subcommands.list.dates.usage')
+      long_desc I18n.t('subcommands.list.dates.long_desc',
+        date_option_description: date_option_description,
+        mnemonic_option_description: mnemonic_option_description)
       option :from, type: :string, required: true, aliases: '-f', banner: 'DATE|MNEMONIC'
-      # -t, --to TO [DATE|MNEMONIC] (e.g. -t, --to 1/1[/yyy]|n|t|y|today|tomorrow|yesterday)
       option :to, type: :string, required: true, aliases: '-t', banner: 'DATE|MNEMONIC'
-      # Include dates that have no DSU entries.
-      option :include_all, type: :boolean, aliases: '-a', desc: 'Include dates that have no DSU entries'
+      option :include_all, default: false, type: :boolean, aliases: '-a', desc: I18n.t('options.include_all')
       def dates
         options = configuration.to_h.merge(self.options).with_indifferent_access
         times, errors = Support::CommandOptions::DsuTimes.dsu_times_for(from_option: options[:from], to_option: options[:to]) # rubocop:disable Layout/LineLength
@@ -149,9 +78,10 @@ module Dsu
         # NOTE: special sort here, unlike the other commands where rules for
         # displaying DSU entries are applied; this is more of a list command.
         times = times_sort(times: times, entries_display_order: options[:entries_display_order])
-        view_entry_groups(times: times, options: options) do |total_entry_groups, _total_entry_groups_not_shown|
-          # nothing_to_display_banner_for(times) if total_entry_groups.zero?
-          Views::EntryGroup::Shared::NoEntriesToDisplay.new(times: times, options: options) if total_entry_groups.zero?
+        view_entry_groups(times: times, options: options) do |_total_entry_groups, _total_entry_groups_not_shown|
+          if Services::EntryGroup::CounterService.new(times: times).call.zero?
+            Views::EntryGroup::Shared::NoEntriesToDisplay.new(times: times, options: options).render
+          end
         end
       rescue ArgumentError => e
         Views::Shared::Error.new(messages: e.message).render

data/lib/dsu/subcommands/theme.rb

@@ -11,142 +11,108 @@ require_relative 'base_subcommand'
 module Dsu
   module Subcommands
     class Theme < BaseSubcommand
-      map %w[c] => :create if Dsu.env.test?
-      map %w[d] => :delete if Dsu.env.test?
+      map %w[c] => :create if Dsu.env.local?
+      map %w[d] => :delete if Dsu.env.local?
       map %w[l] => :list
       map %w[s] => :show
       map %w[u] => :use
 
-      if Dsu.env.test?
-        desc 'create THEME_NAME [OPTIONS]',
-          'Creates a dsu color theme named THEME_NAME.'
-        long_desc <<-LONG_DESC
-        Create a dsu color theme named THEME_NAME in the #{Support::Fileable.themes_folder} folder.
-
-        SYNOPSIS
-
-        `dsu create THEME_NAME [-d|--description DESCRIPTION]`
-
-        OPTIONS:
-
-        -d|--description DESCRIPTION: Creates the dsu color theme with having DESCRIPTION as the color theme description.
-
-        DESCRIPTION:
-
-        Must be be between 2 and 256 characters (inclusive) in length.
-        LONG_DESC
+      if Dsu.env.local?
+        desc I18n.t('subcommands.theme.create.desc'), I18n.t('subcommands.theme.create.usage')
+        long_desc I18n.t('subcommands.theme.create.long_desc', themes_folder: Support::Fileable.themes_folder)
         option :description, type: :string, aliases: '-d', banner: 'DESCRIPTION'
         option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
         def create(theme_name)
           if Models::ColorTheme.exist?(theme_name: theme_name)
-            Views::Shared::Error.new(messages: "Color theme \"#{theme_name}\" already exists.").render
+            message = I18n.t('subcommands.theme.create.errors.already_exists', theme_name: theme_name)
+            Views::Shared::Error.new(messages: message).render
             return false
           end
-          prompt = color_theme.prompt_with_options(prompt: "Create color theme \"#{theme_name}\"?", options: %w[y N])
+          prompt_string = I18n.t('subcommands.theme.create.prompts.create_theme', theme_name: theme_name)
+          prompt = color_theme.prompt_with_options(prompt: prompt_string, options: %w[y N])
           if yes?(prompt, options: options)
             theme_hash = Models::ColorTheme::DEFAULT_THEME.dup
-            theme_hash[:description] = options[:description] || "#{theme_name.capitalize} color theme"
+            theme_hash[:description] = options[:description] || I18n.t('subcommands.theme.generic.color_theme',
+              theme_name: theme_name.capitalize)
             Models::ColorTheme.new(theme_name: theme_name, theme_hash: theme_hash).save!
-            Views::Shared::Info.new(messages: "\nCreated color theme \"#{theme_name}\".").render
+            message = I18n.t('subcommands.theme.create.messages.created', theme_name: theme_name)
+            Views::Shared::Info.new(messages: "\n#{message}").render
             true
           else
-            Views::Shared::Info.new(messages: "\nCanceled.").render
+            message = I18n.t('subcommands.theme.create.messages.canceled')
+            Views::Shared::Info.new(messages: "\n#{message}").render
             false
           end
         end
 
-        desc 'delete THEME_NAME',
-          'Deletes the existing dsu color theme THEME_NAME.'
-        long_desc <<-LONG_DESC
-        NAME
-
-        `dsu delete [THEME_NAME]` -- will delete the dsu color theme named THEME_NAME located in the #{Support::Fileable.themes_folder} folder.
-        LONG_DESC
+        desc I18n.t('subcommands.theme.delete.desc'), I18n.t('subcommands.theme.delete.usage')
+        long_desc I18n.t('subcommands.theme.delete.long_desc', themes_folder: Support::Fileable.themes_folder)
         option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
-        def delete(theme_name)
+        def delete(theme_name) # rubocop:disable Metrics/MethodLength
           display_dsu_header
 
           if theme_name == Models::ColorTheme::DEFAULT_THEME_NAME
-            display_dsu_header
-            Views::Shared::Error.new(messages: "Color theme \"#{theme_name}\" cannot be deleted.").render
+            message = I18n.t('subcommands.theme.delete.errors.cannot_delete', theme_name: theme_name)
+            Views::Shared::Error.new(messages: message).render
             return
           end
 
           unless Models::ColorTheme.exist?(theme_name: theme_name)
-            Views::Shared::Error.new(messages: "Color theme \"#{theme_name}\" does not exist.").render
+            message = I18n.t('subcommands.theme.generic.errors.does_not_exist', theme_name: theme_name)
+            Views::Shared::Error.new(messages: message).render
             return
           end
 
-          prompt = color_theme.prompt_with_options(prompt: "Delete color theme \"#{theme_name}\"?",
-            options: %w[y N])
-          if yes?(prompt, options: options)
+          prompt_string = I18n.t('subcommands.theme.delete.prompts.delete_theme', theme_name: theme_name)
+          prompt = color_theme.prompt_with_options(prompt: prompt_string, options: %w[y N])
+          message = if yes?(prompt, options: options)
             Models::ColorTheme.delete!(theme_name: theme_name)
-            Views::Shared::Info.new(messages: "\nDeleted color theme \"#{theme_name}\".").render
+            change_theme
+            I18n.t('subcommands.theme.delete.messages.deleted', theme_name: theme_name)
           else
-            Views::Shared::Info.new(messages: "\nCanceled.").render
+            I18n.t('subcommands.theme.delete.messages.canceled')
           end
+          Views::Shared::Info.new(messages: "\n#{message}").render
         end
       end
 
-      desc 'list',
-        'Lists the available dsu color themes.'
-      long_desc <<-LONG_DESC
-      NAME
-
-      `dsu list` -- lists the available dsu color themes located in the #{Support::Fileable.themes_folder} folder.
-      LONG_DESC
+      desc I18n.t('subcommands.theme.list.desc'), I18n.t('subcommands.theme.list.usage')
+      long_desc I18n.t('subcommands.theme.list.long_desc', themes_folder: Support::Fileable.themes_folder)
       def list
         Views::ColorTheme::Index.new.render
       end
 
-      desc 'use THEME_NAME',
-        'Sets THEME_NAME as the current DSU color theme.'
-      long_desc <<-LONG_DESC
-      NAME
-
-      `dsu theme use [THEME_NAME]` -- sets the dsu color theme to THEME_NAME.
-
-      SYNOPSIS
-
-      If THEME_NAME is not provided, the default theme will be used.
-      If THEME_NAME does not exist, you will be given the option to create a new theme.
-
-      LONG_DESC
+      desc I18n.t('subcommands.theme.use.desc'), I18n.t('subcommands.theme.use.usage')
+      long_desc I18n.t('subcommands.theme.use.long_desc')
       option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
       def use(theme_name = Models::ColorTheme::DEFAULT_THEME_NAME)
-        if Dsu.env.test? && !Models::ColorTheme.exist?(theme_name: theme_name)
-          display_dsu_header
-          return unless create(theme_name)
-        end
+        display_dsu_header
+
+        return if Dsu.env.local? && !Models::ColorTheme.exist?(theme_name: theme_name) && !create(theme_name)
 
         unless Models::ColorTheme.exist?(theme_name: theme_name)
-          display_dsu_header
-          Views::Shared::Error.new(messages: "Color theme \"#{theme_name}\" does not exist.").render
+          message = I18n.t('subcommands.theme.generic.errors.does_not_exist', theme_name: theme_name)
+          Views::Shared::Error.new(messages: message).render
           return
         end
 
-        configuration.theme_name = theme_name
-        configuration.save!
+        change_theme theme_name: theme_name
         # We need to display the header after the theme is updated so that it is displayed in the
         # correct theme color.
-        display_dsu_header
-        Views::Shared::Info.new(messages: "Using color theme \"#{theme_name}\".").render
+        message = I18n.t('subcommands.theme.use.messages.using_color_theme', theme_name: theme_name)
+        Views::Shared::Info.new(messages: message).render
       end
 
-      desc 'show THEME_NAME',
-        'Displays the dsu color theme.'
-      long_desc <<-LONG_DESC
-      NAME
-
-      `dsu show THEME_NAME` -- displays the dsu color theme for THEME_NAME.
-      LONG_DESC
+      desc I18n.t('subcommands.theme.show.desc'), I18n.t('subcommands.theme.show.usage')
+      long_desc I18n.t('subcommands.theme.show.long_desc')
       def show(theme_name = configuration.theme_name)
         if Dsu::Models::ColorTheme.exist?(theme_name: theme_name)
           Views::ColorTheme::Show.new(theme_name: theme_name).render
           return
         end
 
-        Views::Shared::Error.new(messages: "Color theme \"#{theme_name}\" does not exist.").render
+        message = I18n.t('subcommands.theme.generic.errors.does_not_exist', theme_name: theme_name)
+        Views::Shared::Error.new(messages: message).render
       end
 
       private
@@ -154,6 +120,11 @@ module Dsu
       def display_dsu_header
         self.class.display_dsu_header
       end
+
+      def change_theme(theme_name: Models::ColorTheme::DEFAULT_THEME_NAME)
+        configuration.theme_name = theme_name
+        configuration.save!
+      end
     end
   end
 end

data/lib/dsu/support/ask.rb

@@ -23,7 +23,7 @@ module Dsu
       def auto_prompt(prompt, options)
         prompt = Utils.strip_escapes(prompt)
         @auto_prompt ||= begin
-          value = options.dig('prompts', prompt)
+          value = options.dig('prompts', prompt) || options.dig('prompts', 'any')
           value = (value == 'true' unless value.nil?)
           value
         end

data/lib/dsu/support/command_help_colorizeable.rb

@@ -12,11 +12,18 @@ module Dsu
         end
 
         module ClassMethods
+          # Handles general help colorization.
           def help(shell, subcommand = false) # rubocop:disable Style/OptionalBooleanParameter
             help_text = Services::StdoutRedirectorService.call { super }
             puts apply_theme(help_text, theme_color: color_theme.help)
           end
 
+          # Handles sub-command help colorization.
+          def command_help(shell, subcommand = false) # rubocop:disable Style/OptionalBooleanParameter
+            help_text = Services::StdoutRedirectorService.call { super }
+            puts apply_theme(help_text, theme_color: color_theme.help)
+          end
+
           def color_theme
             @color_theme ||= Models::ColorTheme.current_or_default
           end

data/lib/dsu/support/command_hookable.rb

@@ -35,11 +35,13 @@ module Dsu
         def suspend_header?(args, _options)
           return false unless args.count > 1
 
+          # TODO: I18n?
           true if args[0] == 'theme' && %w[use delete].include?(args[1])
         end
 
         def display_dsu_footer
           puts apply_theme('_' * 35, theme_color: color_theme.dsu_footer)
+          # TODO: I18n.
           footer = apply_theme("Theme: #{color_theme.theme_name}", theme_color: color_theme.dsu_footer)
           puts footer
         end

data/lib/dsu/support/command_options/dsu_times.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'time'
-require_relative 'time_mneumonic'
+require_relative 'time_mnemonic'
 
 module Dsu
   module Support
@@ -11,14 +11,14 @@ module Dsu
 
         # Returns an array of Time objects. The first element is the "from" time.
         # The second element is the "to" time. Both arguments are expected to be
-        # command options that are time strings, time or relative time mneumonics.
+        # command options that are time strings, time or relative time mnemonics.
         def dsu_times_for(from_option:, to_option:)
           from_time = dsu_from_time_for(from_option: from_option)
           to_time = dsu_to_time_for(to_option: to_option, from_time: from_time)
 
           errors = []
-          errors << "Option -f, [--from=DATE|MNEMONIC] value is invalid [\"#{from_option}\"]" if from_time.nil?
-          errors << "Option -t, [--to=DATE|MNEMONIC] value is invalid [\"#{to_option}\"]" if to_time.nil?
+          errors << I18n.t('errors.from_option_invalid', from_option: from_option) if from_time.nil?
+          errors << I18n.t('errors.to_option_invalid', to_option: to_option) if to_time.nil?
           return [[], errors] if errors.any?
 
           min_time, max_time = [from_time, to_time].sort
@@ -28,17 +28,17 @@ module Dsu
         def dsu_from_time_for(from_option:)
           return if from_option.nil?
 
-          from_time = if TimeMneumonic.time_mneumonic?(from_option)
-            TimeMneumonic.time_from_mneumonic(command_option: from_option)
+          from_time = if TimeMnemonic.time_mnemonic?(from_option)
+            TimeMnemonic.time_from_mnemonic(command_option: from_option)
           end
           from_time || Time.time_from_date_string(command_option: from_option)
         end
 
         def dsu_to_time_for(to_option:, from_time:)
-          to_time = if TimeMneumonic.relative_time_mneumonic?(to_option)
-            TimeMneumonic.time_from_mneumonic(command_option: to_option, relative_time: from_time)
-          elsif TimeMneumonic.time_mneumonic?(to_option)
-            TimeMneumonic.time_from_mneumonic(command_option: to_option)
+          to_time = if TimeMnemonic.relative_time_mnemonic?(to_option)
+            TimeMnemonic.time_from_mnemonic(command_option: to_option, relative_time: from_time)
+          elsif TimeMnemonic.time_mnemonic?(to_option)
+            TimeMnemonic.time_from_mnemonic(command_option: to_option)
           end
           to_time || Time.time_from_date_string(command_option: to_option)
         end

data/lib/dsu/support/command_options/time.rb

@@ -67,6 +67,7 @@ module Dsu
 
         def valid_time!(time_parts:)
           time_string = time_string_for(time_parts: time_parts)
+          # TODO: I18n.
           Date.strptime(time_string, '%Y/%m/%d').to_time
         end
 

data/lib/dsu/support/command_options/time_mnemonic.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative 'time_mnemonics'
+
+module Dsu
+  module Support
+    module CommandOptions
+      # The purpose of this module is to take a command option that is a string and return a Time object.
+      # The command option is expected to be a time mneumoic.
+      module TimeMnemonic
+        include TimeMnemonics
+
+        module_function
+
+        def time_from_mnemonic(command_option:, relative_time: nil)
+          time_from_mnemonic!(command_option: command_option, relative_time: relative_time)
+        rescue ArgumentError
+          nil
+        end
+
+        # command_option: is expected to me a time mnemonic. If relative_time is NOT nil, all
+        # time mnemonics are relative to relative_time. Otherwise, they are relative to Time.now.
+        # relative_time: is a Time object that is required IF command_option is expected to be
+        # a relative time mnemonic. Otherwise, it is optional.
+        def time_from_mnemonic!(command_option:, relative_time: nil)
+          validate_argument!(command_option: command_option, command_option_name: :command_option)
+          unless relative_time.nil? || relative_time.is_a?(::Time)
+            raise ArgumentError, "relative_time is not a Time object: \"#{relative_time}\""
+          end
+
+          relative_time ||= ::Time.now
+
+          time_for_mnemonic(mnemonic: command_option, relative_time: relative_time)
+        end
+
+        # This method returns true if mnemonic is a valid mnemonic OR
+        # a relative time mnemonic.
+        def time_mnemonic?(mnemonic)
+          mnemonic?(mnemonic) || relative_time_mnemonic?(mnemonic)
+        end
+
+        # This method returns true if mnemonic is a valid relative
+        # time mnemonic.
+        def relative_time_mnemonic?(mnemonic)
+          return false unless mnemonic.is_a?(String)
+
+          mnemonic.match?(RELATIVE_REGEX)
+        end
+
+        # Add private_class_methods here.
+
+        # Returns a Time object from a mnemonic.
+        def time_for_mnemonic(mnemonic:, relative_time:)
+          time = relative_time
+          if today_mnemonic?(mnemonic)
+            time
+          elsif tomorrow_mnemonic?(mnemonic)
+            time.tomorrow
+          elsif yesterday_mnemonic?(mnemonic)
+            time.yesterday
+          elsif relative_time_mnemonic?(mnemonic)
+            relative_time_for(days_from_now: mnemonic, time: time)
+          end
+        end
+
+        def relative_time_for(days_from_now:, time:)
+          days_from_now.to_i.days.from_now(time)
+        end
+
+        # This method returns true if mnemonic is a valid time mnemonic.
+        # This method will return false if mnemonic is an invalid mnemonic
+        # OR if mnemonic is a relative time mnemonic.
+        def mnemonic?(mnemonic)
+          today_mnemonic?(mnemonic) ||
+            tomorrow_mnemonic?(mnemonic) ||
+            yesterday_mnemonic?(mnemonic)
+        end
+
+        def today_mnemonic?(mnemonic)
+          TODAY.include?(mnemonic)
+        end
+
+        def tomorrow_mnemonic?(mnemonic)
+          TOMORROW.include?(mnemonic)
+        end
+
+        def yesterday_mnemonic?(mnemonic)
+          YESERDAY.include?(mnemonic)
+        end
+
+        def validate_argument!(command_option:, command_option_name:)
+          raise ArgumentError, "#{command_option_name} cannot be nil." if command_option.nil?
+          raise ArgumentError, "#{command_option_name} cannot be blank." if command_option.blank?
+          unless command_option.is_a?(String)
+            raise ArgumentError, "#{command_option_name} must be a String: \"#{command_option}\""
+          end
+          unless time_mnemonic?(command_option)
+            raise ArgumentError, "#{command_option_name} is an invalid mnemonic: \"#{command_option}\"."
+          end
+        end
+
+        private_class_method :time_for_mnemonic, :relative_time_for,
+          :mnemonic?, :today_mnemonic?, :tomorrow_mnemonic?,
+          :yesterday_mnemonic?, :validate_argument!
+      end
+    end
+  end
+end