dsu 1.2.1 → 2.0.1

data/lib/dsu/support/color_themable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'colorized_string'
+
+module Dsu
+  module Support
+    module ColorThemable
+      def prompt_with_options(prompt:, options:)
+        options = "[#{options.join('/')}]"
+        "#{apply_theme(prompt, theme_color: self.prompt)} " \
+          "#{apply_theme(options, theme_color: prompt_options)}" \
+          "#{apply_theme('>', theme_color: self.prompt)}"
+      end
+
+      module_function
+
+      def apply_theme(input, theme_color:)
+        if input.is_a?(Array)
+          return input.map do |string|
+            colorize_string(string, theme_color: theme_color)
+          end.join("\n")
+        end
+
+        colorize_string(input, theme_color: theme_color)
+      end
+
+      private
+
+      def colorize_string(input, theme_color:)
+        ColorizedString[input].colorize(**theme_color)
+      end
+    end
+  end
+end

data/lib/dsu/support/command_help_colorizeable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../models/color_theme'
+require_relative '../support/color_themable'
+
+module Dsu
+  module Support
+    module CommandHelpColorizable
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          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
+
+          def color_theme
+            @color_theme ||= Models::ColorTheme.current_or_default
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dsu/support/command_hookable.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../models/color_theme'
+require_relative '../services/stderr_redirector_service'
+require_relative '../views/shared/error'
+require_relative 'color_themable'
+
+module Dsu
+  module Support
+    module CommandHookable
+      class << self
+        def included(base)
+          base.extend(ColorThemable)
+          base.extend(ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        def start(args = ARGV, options = {})
+          display_dsu_header unless suspend_header?(args, options)
+          stderror = Services::StderrRedirectorService.call do
+            super
+          end
+          display_errors_if(stderror)
+          display_dsu_footer
+        end
+
+        def display_dsu_header
+          puts apply_theme("Dsu v#{Dsu::VERSION}", theme_color: color_theme.dsu_header)
+          puts
+        end
+
+        private
+
+        def suspend_header?(args, _options)
+          return unless args.count > 1
+          return 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)
+          footer = apply_theme("Theme: #{color_theme.theme_name}", theme_color: color_theme.dsu_footer)
+          puts footer
+        end
+
+        def display_errors_if(stderror_string)
+          stderror_string = stderror_string.strip
+          return unless stderror_string.present?
+
+          errors = stderror_string.split("\n").map(&:strip)
+          Views::Shared::Error.new(messages: errors, options: options.merge({ ordered_list: false })).render
+        end
+
+        def color_theme
+          Models::ColorTheme.current_or_default
+        end
+      end
+    end
+  end
+end

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

@@ -2,34 +2,45 @@
 
 require_relative 'time'
 require_relative 'time_mneumonic'
-require_relative 'time_mneumonics'
 
 module Dsu
   module Support
     module CommandOptions
       module DsuTimes
-        include Time
-        include TimeMneumonic
-        include TimeMneumonics
-
-        # 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.
-        def dsu_times_from!(from_command_option:, to_command_option:)
-          times = begin
-            from_time = time_from_mneumonic(command_option: from_command_option) if time_mneumonic?(from_command_option)
-            from_time ||= time_from_date_string(command_option: from_command_option)
-
-            to_time = if relative_time_mneumonic?(to_command_option)
-              time_from_mneumonic(command_option: to_command_option, relative_time: from_time)
-            elsif time_mneumonic?(to_command_option)
-              time_from_mneumonic(command_option: to_command_option)
-            end
-            to_time ||= time_from_date_string(command_option: to_command_option)
-
-            [from_time, to_time].sort
+        module_function
+
+        # 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.
+        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?
+          return [[], errors] if errors.any?
+
+          min_time, max_time = [from_time, to_time].sort
+          [(min_time.to_date..max_time.to_date).map(&:to_time), []]
+        end
+
+        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)
           end
+          from_time || Time.time_from_date_string(command_option: from_option)
+        end
 
-          (times.min.to_date..times.max.to_date).map(&:to_time)
+        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)
+          end
+          to_time || Time.time_from_date_string(command_option: to_option)
         end
       end
     end

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

@@ -3,6 +3,8 @@
 module Dsu
   module Support
     module CommandOptions
+      # TODO: Make this into an ActiveModel class that uses validations.
+      #
       # 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 date in the format of [M]M/[D]D[/YYYY]. MM and DD with
       # leading zeroes is optional (i.e. only M and D are required), YYYY is optionl and will be replaced
@@ -10,6 +12,8 @@ module Dsu
       module Time
         DATE_CAPTURE_REGEX = %r{\A(?<month>0?[1-9]|1[0-2])/(?<day>0?[1-9]|1\d|2\d|3[01])(?:/(?<year>\d{4}))?\z}
 
+        module_function
+
         def time_from_date_string!(command_option:)
           raise ArgumentError, 'command_option is nil.' if command_option.nil?
           raise ArgumentError, 'command_option is blank.' if command_option.blank?
@@ -35,7 +39,7 @@ module Dsu
           nil
         end
 
-        private
+        # private_class_methods go here.
 
         # This method returns the time parts for the given time string in a hash
         # (i.e. month, day, year) IF the time string matches the DATE_CAPTURE_REGEX
@@ -71,6 +75,8 @@ module Dsu
           time_parts[:year] = ::Time.now.year if time_parts[:year].nil?
           "#{time_parts[:year]}/#{time_parts[:month]}/#{time_parts[:day]}"
         end
+
+        private_class_method :time_parts_for, :time_parts?, :valid_time!, :time_string_for
       end
     end
   end

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

@@ -10,6 +10,8 @@ module Dsu
       module TimeMneumonic
         include TimeMneumonics
 
+        module_function
+
         def time_from_mneumonic(command_option:, relative_time: nil)
           time_from_mneumonic!(command_option: command_option, relative_time: relative_time)
         rescue ArgumentError
@@ -45,7 +47,7 @@ module Dsu
           mneumonic.match?(RELATIVE_REGEX)
         end
 
-        private
+        # Add private_class_methods here.
 
         # Returns a Time object from a mneumonic.
         def time_for_mneumonic(mneumonic:, relative_time:)
@@ -96,6 +98,10 @@ module Dsu
             raise ArgumentError, "#{command_option_name} is an invalid mneumonic: \"#{command_option}\"."
           end
         end
+
+        private_class_method :time_for_mneumonic, :relative_time_for,
+          :mneumonic?, :today_mneumonic?, :tomorrow_mneumonic?,
+          :yesterday_mneumonic?, :validate_argument!
       end
     end
   end

data/lib/dsu/support/descriptable.rb

@@ -3,9 +3,11 @@
 module Dsu
   module Support
     module Descriptable
+      DESCRIPTION_MAX_COUNT = 25
+
       class << self
-        def included(mod)
-          mod.extend(ClassMethods)
+        def included(base)
+          base.extend(ClassMethods)
         end
       end
 
@@ -16,7 +18,7 @@ module Dsu
       end
 
       module ClassMethods
-        def short_description(string:, count: 25, elipsis: '...')
+        def short_description(string:, count: DESCRIPTION_MAX_COUNT, elipsis: '...')
           return elipsis unless string.is_a?(String)
 
           elipsis_length = elipsis.length
@@ -27,7 +29,7 @@ module Dsu
           tokens = string.split
           string = ''
 
-          return "#{tokens.first[0..(count - elipsis_length)]}#{elipsis}" if tokens.count == 1
+          return "#{tokens.first[0...(count - elipsis_length)]}#{elipsis}" if tokens.count == 1
 
           tokens.each do |token|
             break if string.length + token.length + elipsis_length > count

data/lib/dsu/support/entry_group_viewable.rb

@@ -4,6 +4,9 @@ module Dsu
   module Support
     module EntryGroupViewable
       def view_entry_groups(times:, options: {})
+        raise ArgumentError, 'times must be an Array' unless times.is_a?(Array)
+        raise ArgumentError, 'options must be a Hash' unless options.is_a?(Hash)
+
         total_viewable_entry_groups = 0
 
         times.each do |time|
@@ -13,25 +16,46 @@ module Dsu
           end
         end
 
-        yield total_viewable_entry_groups if block_given?
+        total_unviewable_entry_groups = times.size - total_viewable_entry_groups
+        yield total_viewable_entry_groups, total_unviewable_entry_groups if block_given?
       end
 
       def view_entry_group(time:, options: {})
+        raise ArgumentError, 'time must be a Time object' unless time.is_a?(Time)
+        raise ArgumentError, 'options must be a Hash' unless options.is_a?(Hash)
+
         return unless show_entry_group?(time: time, options: options)
 
-        entry_group = Models::EntryGroup.load(time: time)
+        entry_group = Models::EntryGroup.find_or_initialize(time: time)
         Views::EntryGroup::Show.new(entry_group: entry_group).render
 
         yield if block_given?
       end
 
+      # This method will unconditionally display the FIRST and LAST entry groups
+      # associated with the times provided by the <times> argument. All other
+      # entry groups will be conditionally displayed based on the :include_all
+      # value in the <options> argument.
+      def view_list_for(times:, options:)
+        configuration = Models::Configuration.new unless defined?(configuration) && configuration
+        options = configuration.to_h.merge(options).with_indifferent_access
+        times_first_and_last = [times.first, times.last]
+        times.each do |time|
+          view_options = options.dup
+          view_options[:include_all] = true if times_first_and_last.include?(time)
+          view_entry_group(time: time, options: view_options) do
+            puts
+          end
+        end
+      end
+
       private
 
       def show_entry_group?(time:, options:)
-        Models::EntryGroup.exists?(time: time) || options[:include_all]
+        Models::EntryGroup.exist?(time: time) || options[:include_all]
       end
 
-      module_function :view_entry_group, :view_entry_groups, :show_entry_group?
+      module_function :view_entry_group, :view_entry_groups, :view_list_for, :show_entry_group?
     end
   end
 end

data/lib/dsu/support/fileable.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module Fileable
+      MIGRATION_VERSION_FILE_NAME = 'migration_version.json'
+
+      def dsu_folder
+        File.join(root_folder, 'dsu')
+      end
+
+      # Configuration
+
+      def config_folder
+        root_folder
+      end
+
+      def config_file_name
+        '.dsu'
+      end
+
+      def config_path
+        File.join(config_folder, config_file_name)
+      end
+
+      # Entries
+
+      def entries_folder
+        File.join(dsu_folder, 'entries')
+      end
+
+      def entries_file_name(time:, file_name_format: nil)
+        file_name_format ||= '%Y-%m-%d.json'
+        time.strftime(file_name_format)
+      end
+
+      def entries_path(time:, file_name_format: nil)
+        File.join(entries_folder, entries_file_name(time: time, file_name_format: file_name_format))
+      end
+
+      # Themes
+
+      def themes_folder
+        File.join(dsu_folder, 'themes')
+      end
+
+      def themes_path(theme_name:)
+        File.join(themes_folder, theme_file_name(theme_name: theme_name))
+      end
+
+      def theme_file_name(theme_name:)
+        "#{theme_name}.json"
+      end
+
+      # Migration
+
+      def migration_version_folder
+        File.join(dsu_folder)
+      end
+
+      def migration_version_path
+        File.join(migration_version_folder, MIGRATION_VERSION_FILE_NAME)
+      end
+
+      # Base folders
+
+      def root_folder
+        Dir.home
+      end
+
+      def temp_folder
+        Dir.tmpdir
+      end
+
+      def gem_dir
+        Gem.loaded_specs['dsu'].gem_dir
+      end
+
+      # Back up folder
+
+      def backup_folder(version:)
+        File.join(dsu_folder, 'backup', version.to_s)
+      end
+
+      # Seed data folders
+
+      def seed_data_folder
+        File.join(gem_dir, 'lib/seed_data')
+      end
+
+      extend self # rubocop:disable Style/ModuleFunction
+    end
+  end
+end

data/lib/dsu/support/presentable.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module Presentable
+      def presenter
+        "Dsu::Presenters::#{self.class.name.demodulize}Presenter".constantize.new(self, options: options)
+      end
+    end
+  end
+end

data/lib/dsu/support/subcommand_help_colorizeable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../models/color_theme'
+require_relative '../support/color_themable'
+
+module Dsu
+  module Support
+    module SubcommandHelpColorizable
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          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
+        end
+      end
+    end
+  end
+end

data/lib/dsu/support/time_comparable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module TimeComparable
+      TIME_COMPARABLE_FORMAT_SPECIFIER = '%Y%m%d'
+
+      def time_equal?(other_time:)
+        time_equal_compare_string_for(time: time) == time_equal_compare_string_for(time: other_time)
+      end
+
+      def time_equal_compare_string_for(time:)
+        time = time.localtime if time.utc?
+
+        time.strftime(TIME_COMPARABLE_FORMAT_SPECIFIER)
+      end
+    end
+  end
+end

data/lib/dsu/support/time_formatable.rb

@@ -28,9 +28,21 @@ module Dsu
         time.strftime("%A, (#{today_yesterday_or_tomorrow}) %Y-%m-%d #{time_zone}")
       end
 
+      def mm_dd(time:, separator: '/')
+        time.strftime("%m#{separator}%d")
+      end
+
+      def mm_dd_yyyy(time:, separator: '/')
+        time.strftime("%m#{separator}%d#{separator}%Y")
+      end
+
       def timezone_for(time:)
         time.zone
       end
+
+      def yyyy_mm_dd(time:, separator: '-')
+        time.strftime("%Y#{separator}%m#{separator}%d")
+      end
     end
   end
 end

data/lib/dsu/support/times_sortable.rb

@@ -3,29 +3,41 @@
 module Dsu
   module Support
     module TimesSortable
-      module_function
+      def sorted_dsu_times_for(times:)
+        configuration = Models::Configuration.new unless defined?(configuration) && configuration
+        entries_display_order = configuration.entries_display_order
+        times_sort(times: times_for(times: times), entries_display_order: entries_display_order)
+      end
 
       def times_sort(times:, entries_display_order: nil)
-        entries_display_order ||= 'asc'
-        unless %w[asc desc].include? entries_display_order
-          raise "Invalid entries_display_order: #{entries_display_order}"
-        end
+        times = times.dup
+        entries_display_order ||= :asc
 
-        if entries_display_order == 'asc'
-          times.sort # sort ascending
-        elsif entries_display_order == 'desc'
-          times.sort.reverse # sort descending
-        end
+        validate_times_argument!(times: times)
+        validate_entries_display_order_argument!(entries_display_order: entries_display_order)
+
+        return times if times.one?
+
+        # NOTE: The times array needs to be sorted unconditionally because if
+        # the sort is ascending, then the times array needs to be returned
+        # in ascending order. If the sort is descending, then in order to
+        # properly reverse the times array, it needs to first be sorted in
+        # ascending order before being reversed.
+        times.sort!
+        times.reverse! if entries_display_order == :desc
+
+        times
       end
 
-      # TODO: Do we have something else we can use here?
       def times_for(times:)
+        times = times.dup
+        validate_times_argument!(times: times)
+
         start_date = times.max
         return times unless start_date.monday? || start_date.on_weekend?
 
-        # If the start_date is a weekend or a Monday, then we need to include
-        # start_date along with all the dates up to and including the previous
-        # Monday.
+        # If the start date is a weekend or a Monday then we need to look back
+        # to include the preceeding Friday upto and including the start date.
         (0..3).filter_map do |num|
           time = start_date - num.days
           next unless time == start_date || time.on_weekend? || time.friday?
@@ -33,6 +45,28 @@ module Dsu
           time
         end
       end
+
+      private
+
+      def validate_times_argument!(times:)
+        raise ArgumentError, "times is the wrong object type: \"#{times.class}\"" unless times.is_a?(Array)
+        raise ArgumentError, 'times is empty' if times.empty?
+      end
+
+      def validate_entries_display_order_argument!(entries_display_order:)
+        unless entries_display_order.nil? || entries_display_order.is_a?(Symbol)
+          raise ArgumentError, "entries_display_order is the wrong object type: \"#{entries_display_order.class}\""
+        end
+
+        unless %i[asc desc].include?(entries_display_order)
+          raise ArgumentError, "entries_display_order is invalid: \":#{entries_display_order}\""
+        end
+      end
+
+      # NOTE: This, as opposed to using module_function, so that we can
+      # invoke .validate_times_sort_arguments! from the .times_sort
+      # method with module as the receiver AND when included as a mixin.
+      extend self
     end
   end
 end

data/lib/dsu/support/utils.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Utils
+    class << self
+      def strip_escapes(escaped_string)
+        escaped_string.gsub(/\e\[[0-9;]*[a-zA-Z]/, '')
+      end
+    end
+  end
+end