dsu 1.2.0 → 2.0.0.alpha.1

data/lib/dsu/validators/color_theme_validator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'colorize'
+
+# rubocop:disable Layout/LineLength
+module Dsu
+  module Validators
+    class ColorThemeValidator < ActiveModel::Validator
+      def validate(record)
+        default_theme_colors = record.class::DEFAULT_THEME_COLORS
+
+        # return unless validate_color_theme_keys!(record, default_theme_colors)
+
+        default_theme_colors.each_key do |theme_color_key|
+          theme_colors_hash = record.public_send(theme_color_key)
+
+          next unless validate_theme_color_type!(record, theme_color_key, theme_colors_hash)
+
+          if theme_colors_hash.empty?
+            record.errors.add(:base, ":#{theme_color_key} colors Hash is empty")
+            next
+          end
+
+          validate_theme_colors!(record, theme_colors_hash)
+        end
+      end
+
+      private
+
+      def colors
+        @colors ||= String.colors
+      end
+
+      def modes
+        @modes ||= String.modes
+      end
+
+      def validate_theme_color_type!(record, theme_color_key, theme_colors_hash)
+        return true if theme_colors_hash.is_a?(Hash)
+
+        record.errors.add(:base, ":#{theme_color_key} value is the wrong object type. " \
+                                 "\"Hash\" was expected, but \"#{theme_colors_hash.class}\" was received.")
+        false
+      end
+
+      def validate_theme_colors!(record, theme_colors_hash)
+        unless colors.include?(theme_colors_hash[:color])
+          value = theme_color_value_to_s(theme_colors_hash[:color])
+          record.errors.add(:base, ":color key value #{value} in theme color Hash #{theme_colors_hash} is not a valid color. " \
+                                   "One of #{colors.wrap_and_join(wrapper: [':', ''])} was expected, but #{value} was received.")
+        end
+
+        unless theme_colors_hash[:mode].nil? || modes.include?(theme_colors_hash[:mode])
+          value = theme_color_value_to_s(theme_colors_hash[:mode])
+          record.errors.add(:base, ":mode key value #{value} in theme color Hash #{theme_colors_hash} is not a valid mode value. " \
+                                   "One of #{modes.wrap_and_join(wrapper: [':', ''])} was expected, but #{value} was received.")
+        end
+
+        unless theme_colors_hash[:background].nil? || colors.include?(theme_colors_hash[:background])
+          value = theme_color_value_to_s(theme_colors_hash[:background])
+          record.errors.add(:base, ":background key value #{value} in theme color Hash #{theme_colors_hash} is not a valid color. " \
+                                   "One of #{colors.wrap_and_join(wrapper: [':', ''])} was expected, but #{value} was received.")
+        end
+      end
+
+      def theme_color_value_to_s(theme_color_value)
+        return ":#{theme_color_value}" if theme_color_value.is_a?(Symbol)
+
+        "'#{theme_color_value}'"
+      end
+    end
+  end
+end
+# rubocop:enable Layout/LineLength

data/lib/dsu/validators/entries_validator.rb

@@ -17,8 +17,8 @@ module Dsu
         end
 
         return if validate_entry_types record
-        return if validate_unique_entry record
 
+        validate_unique_entry record
         validate_entries record
       end
 
@@ -45,9 +45,9 @@ module Dsu
         return if descriptions.uniq.length == descriptions.length
 
         non_unique_descriptions = descriptions.select { |description| descriptions.count(description) > 1 }.uniq
-        if non_unique_descriptions.any?
-          record.errors.add(:entries, 'Array contains a duplicate entry: ' \
-                                      "#{format_non_unique_descriptions(non_unique_descriptions)}.",
+        non_unique_descriptions.each do |non_unique_description|
+          record.errors.add(:entries,
+            "array contains duplicate entry: \"#{short_description(non_unique_description)}\".",
             type: Support::FieldErrors::FIELD_DUPLICATE_ERROR)
         end
 
@@ -67,10 +67,6 @@ module Dsu
         end
       end
 
-      def format_non_unique_descriptions(non_unique_descriptions)
-        non_unique_descriptions.map { |description| "\"#{short_description(description)}\"" }.join(', ')
-      end
-
       def short_description(description)
         Models::Entry.short_description(string: description)
       end

data/lib/dsu/validators/version_validator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# https://guides.rubyonrails.org/active_record_validations.html#validates-with
+module Dsu
+  module Validators
+    class VersionValidator < ActiveModel::Validator
+      def validate(record)
+        version = record.version
+
+        if version.nil?
+          record.errors.add(:version, 'is nil')
+          return
+        end
+
+        unless version.is_a?(Integer)
+          record.errors.add(:version, 'is the wrong object type. ' \
+                                      "\"Integer\" was expected, but \"#{version.class}\" was received.")
+          nil
+        end
+
+        # TODO: This validation should check the configuration version
+        # against the current migration version and they should match.
+        # unless version == record.class::VERSION
+        #   record.errors.add(:version, "\"#{version}\" is not the correct version: \"#{record.class::VERSION}\"")
+        # end
+      end
+    end
+  end
+end

data/lib/dsu/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module Dsu
-  VERSION = '1.2.0'
+  VERSION_REGEX = /\A\d+\.\d+\.\d+(\.alpha\.\d+)?\z/
+  VERSION = '2.0.0.alpha.1'
 end

data/lib/dsu/views/color_theme/index.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../../models/configuration'
+require_relative '../../models/color_theme'
+
+module Dsu
+  module Views
+    module ColorTheme
+      class Index
+        include Support::ColorThemable
+
+        def render
+          render!
+        end
+
+        private
+
+        def render!
+          presenter = color_theme.presenter
+          puts presenter.header
+          puts
+          render_theme_details
+          puts
+          puts presenter.footer
+        end
+
+        def render_theme_details
+          themes_folder = Models::Configuration.new.themes_folder
+          theme_file_names = Dir.glob("#{themes_folder}/*").map { |theme_path| File.basename(theme_path, '.*') }
+          theme_file_names << default_theme_name unless theme_file_names.include?(default_theme_name)
+          theme_file_names.sort.each_with_index do |theme_file, index|
+            color_theme = if theme_file == default_theme_name
+              default_theme
+            else
+              Models::ColorTheme.find(theme_name: theme_file)
+            end
+            presenter = color_theme.presenter
+            puts presenter.detail_with_index(index: index)
+          end
+        end
+
+        # When getting the default theme, if it exists on disk, use that; otherwise,
+        # use the in-memory default theme.
+        def default_theme
+          if Models::ColorTheme.exist?(theme_name: default_theme_name)
+            Models::ColorTheme.find(theme_name: default_theme_name)
+          else
+            Models::ColorTheme.default
+          end
+        end
+
+        def default_theme_name
+          Dsu::Models::ColorTheme::DEFAULT_THEME_NAME
+        end
+
+        def color_theme
+          @color_theme ||= Models::ColorTheme.current_or_default
+        end
+      end
+    end
+  end
+end

data/lib/dsu/views/color_theme/show.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative '../../models/color_theme'
+require_relative '../../models/configuration'
+require_relative '../entry_group/show'
+require_relative '../shared/error'
+require_relative '../shared/info'
+require_relative '../shared/success'
+require_relative '../shared/warning'
+
+module Dsu
+  module Views
+    module ColorTheme
+      class Show
+        include Support::ColorThemable
+
+        def initialize(theme_name:, options: {})
+          @theme_name = theme_name
+          @options = options || {}
+        end
+
+        def render
+          render!
+        end
+
+        private
+
+        attr_reader :theme_name, :options
+
+        def color_theme
+          @color_theme ||= Models::ColorTheme.find_or_initialize(theme_name: theme_name)
+        end
+
+        def presenter
+          @presenter ||= Dsu::Presenters::ColorThemeShowPresenter.new(color_theme, options: options)
+        end
+
+        def render!
+          puts presenter.header
+          puts
+
+          presenter.detail
+          puts
+
+          display_entry_group_example
+          puts
+
+          display_configuration_example
+          puts
+
+          display_messages_example
+          puts
+
+          puts presenter.footer
+        end
+
+        def display_entry_group_example
+          puts apply_theme('`dsu list` example', theme_color: color_theme.subheader)
+          puts
+
+          options = custom_options
+          entry_group = mock_entry_group(options)
+          EntryGroup::Show.new(entry_group: entry_group, options: options).render
+        end
+
+        def display_configuration_example
+          puts apply_theme('`dsu config info` example', theme_color: color_theme.subheader)
+          puts
+
+          Views::Configuration::Show.new(config: Models::Configuration.new(options: custom_options)).render
+        end
+
+        def display_messages_example
+          options = custom_options
+          messages = ['Example 1', 'Example 2', 'Example 3']
+
+          puts apply_theme('Message examples', theme_color: color_theme.subheader)
+          puts
+
+          Shared::Error.new(messages: messages, header: 'Errors example', options: options).render
+          puts
+
+          Shared::Info.new(messages: messages, header: 'Info example', options: options).render
+          puts
+
+          Shared::Success.new(messages: messages, header: 'Success example', options: options).render
+          puts
+
+          Shared::Warning.new(messages: messages, header: 'Warning example', options: options).render
+        end
+
+        def mock_entry_group(options)
+          @mock_entry_group ||= Dsu::Models::EntryGroup.new(time: Time.now, entries: [
+            Dsu::Models::Entry.new(description: 'Dsu entry 1', options: options),
+            Dsu::Models::Entry.new(description: 'Dsu entry 2', options: options),
+            Dsu::Models::Entry.new(description: 'Dsu entry 3', options: options)
+          ], options: options)
+        end
+
+        def custom_options
+          options.merge(theme_name: color_theme.theme_name, output_stream: $stdout)
+        end
+      end
+    end
+  end
+end

data/lib/dsu/views/configuration/show.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'active_support/core_ext/numeric/time'
+require_relative '../../models/configuration'
+require_relative '../../support/color_themable'
+
+module Dsu
+  module Views
+    module Configuration
+      class Show
+        include Support::ColorThemable
+
+        def initialize(config:, options: {})
+          raise ArgumentError, 'config is nil' if config.nil?
+          raise ArgumentError, 'config is the wrong object type' unless config.is_a?(Models::Configuration)
+          raise ArgumentError, 'options is nil' if options.nil?
+          raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash)
+
+          @config = config
+          @options = options || {}
+        end
+
+        def call
+          render!
+        end
+        alias render call
+
+        private
+
+        attr_reader :config, :options
+
+        def render!
+          presenter = config.presenter
+          puts presenter.configuration_header
+          puts presenter.configuration_details
+        end
+      end
+    end
+  end
+end

data/lib/dsu/views/entry_group/edit.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
+require_relative '../../models/configuration'
 require_relative '../../models/entry_group'
-require_relative '../../support/configurable'
 
 module Dsu
   module Views
     module EntryGroup
       class Edit
-        include Support::Configurable
-
         def initialize(entry_group:, options: {})
           raise ArgumentError, 'entry_group is nil' if entry_group.nil?
           raise ArgumentError, 'entry_group is the wrong object type' unless entry_group.is_a?(Models::EntryGroup)
@@ -100,7 +98,7 @@ module Dsu
         end
 
         def previous_entry_group?
-          previous_entry_group.present?
+          previous_entry_group.entries.present?
         end
 
         def previous_entry_group
@@ -108,13 +106,13 @@ module Dsu
           # TODO: Make this configurable or accept an option?
           @previous_entry_group ||= (1..7).each do |days|
             t = time.days_ago(days)
-            return Models::EntryGroup.load(time: t) if Support::EntryGroupFileable.entry_group_file_exists?(time: t)
+            return Models::EntryGroup.find(time: t) if Models::EntryGroup.exist?(time: t)
           end
           nil
         end
 
         def carry_over_entries_to_today?
-          configuration[:carry_over_entries_to_today]
+          Models::Configuration.new.merge(options).carry_over_entries_to_today?
         end
       end
     end

data/lib/dsu/views/entry_group/shared/no_entries_to_display.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../../models/color_theme'
+require_relative '../../../support/color_themable'
+require_relative '../../../support/time_formatable'
+
+module Dsu
+  module Views
+    module EntryGroup
+      module Shared
+        class NoEntriesToDisplay
+          include Support::ColorThemable
+          include Support::TimeFormatable
+
+          def initialize(times:, options: {})
+            raise ArgumentError, 'times must be an Array' unless times.is_a?(Array)
+            raise ArgumentError, 'times must contain Time objects' unless times.all?(Time)
+            raise ArgumentError, 'options must be a Hash' unless options.is_a?(Hash) || options.nil?
+
+            @times = times
+            @options = options || {}
+          end
+
+          def render
+            entry_group_times.sort!
+            time_range = "#{formatted_time(time: times.first)} " \
+                         "through #{formatted_time(time: times.last)}"
+            message = "(nothing to display for #{time_range})"
+            puts apply_theme(message, theme_color: color_theme.info)
+          end
+
+          private
+
+          def color_theme
+            @color_theme ||= Models::ColorTheme.current_or_default
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dsu/views/entry_group/show.rb

@@ -3,16 +3,14 @@
 require 'time'
 require 'active_support/core_ext/numeric/time'
 require_relative '../../models/entry_group'
-require_relative '../../support/colorable'
-require_relative '../../support/say'
+require_relative '../../support/color_themable'
 require_relative '../../support/time_formatable'
 
 module Dsu
   module Views
     module EntryGroup
       class Show
-        include Support::Colorable
-        include Support::Say
+        include Support::ColorThemable
         include Support::TimeFormatable
 
         def initialize(entry_group:, options: {})
@@ -35,22 +33,25 @@ module Dsu
         attr_reader :entry_group, :options
 
         def render!
-          say formatted_time(time: entry_group.time), HIGHLIGHT
-          say('(no entries available for this day)') and return if entry_group.entries.empty?
+          puts presenter.formatted_time
+
+          entry_group.validate!
+          puts presenter.no_entries_available and return if entry_group.entries.empty?
 
           entry_group.entries.each_with_index do |entry, index|
-            prefix = "#{format('%03s', index + 1)}. "
-            description = colorize_string(string: entry.description, mode: :bold)
-            entry_info = "#{prefix} #{description}"
-            unless entry.valid?
-              entry_info = "#{entry_info} (validation failed: #{entry_errors(entry_group_deleter_service)})"
-            end
-            say entry_info
+            entry_presenter = entry.presenter
+            puts entry_presenter.formatted_description_with_index(index: index)
           end
+        rescue ActiveModel::ValidationError
+          puts apply_theme(errors(entry_group), theme_color: presenter.color_theme.error)
+        end
+
+        def errors(model)
+          model.errors.full_messages.join(', ')
         end
 
-        def entry_errors(entry)
-          entry.errors.full_messages.join(', ')
+        def presenter
+          @presenter ||= entry_group.presenter
         end
       end
     end

data/lib/dsu/views/shared/error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'message'
+
+module Dsu
+  module Views
+    module Shared
+      class Error < Message
+        def initialize(messages:, header: nil, options: {})
+          options = { header: header, output_stream: $stderr }.merge(options)
+
+          super(messages: messages, message_type: :error, options: options)
+        end
+      end
+    end
+  end
+end

data/lib/dsu/views/shared/info.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'message'
+
+module Dsu
+  module Views
+    module Shared
+      class Info < Message
+        def initialize(messages:, header: nil, options: {})
+          options = { header: header, output_stream: $stdout }.merge(options)
+
+          super(messages: messages, message_type: :info, options: options)
+        end
+      end
+    end
+  end
+end

data/lib/dsu/views/shared/message.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../../models/color_theme'
+
+module Dsu
+  module Views
+    module Shared
+      class Message
+        include Support::ColorThemable
+
+        MESSAGE_TYPES = %i[error info success warning].freeze
+
+        def initialize(messages:, message_type:, options: {})
+          messages = [messages] unless messages.is_a?(Array)
+          messages = messages.select(&:present?)
+
+          validate_arguments!(messages, message_type, options)
+
+          @messages = messages
+          @message_type = message_type
+          @options = options || {}
+          @message_color = color_theme.public_send(message_type)
+          @header = options[:header]
+          @ordered_list = options.fetch(:ordered_list, true)
+        end
+
+        def render
+          output_stream.puts to_s
+        end
+
+        def to_s
+          return if messages.empty?
+
+          strings = []
+
+          strings << apply_theme(header, theme_color: color_theme.header) if header.present?
+
+          strings << if messages.one?
+            apply_theme(messages[0], theme_color: message_color)
+          else
+            messages.each_with_index.map do |message, index|
+              message = "#{index + 1}. #{message}" if ordered_list?
+              apply_theme(message, theme_color: message_color)
+            end
+          end
+
+          strings.flatten.join("\n")
+        end
+
+        private
+
+        attr_reader :messages, :message_color, :message_type, :header, :options
+
+        def color_theme
+          @color_theme ||= begin
+            theme_name = options.fetch(:theme_name, Models::Configuration.new.theme_name)
+            Models::ColorTheme.find(theme_name: theme_name)
+          end
+        end
+
+        def ordered_list?
+          @ordered_list
+        end
+
+        def output_stream
+          @output_stream ||= options.fetch(:output_stream, $stdout)
+        end
+
+        def validate_arguments!(messages, message_type, options)
+          raise ArgumentError, 'messages is empty' if messages.empty?
+          unless Models::ColorTheme::DEFAULT_THEME_COLORS.key?(message_type)
+            raise ArgumentError, 'message_type is not a valid message type'
+          end
+          raise ArgumentError, 'options is nil' if options.nil?
+
+          %i[\[\] fetch].each do |method|
+            next if options.respond_to?(method)
+
+            raise ArgumentError, "options does not respond to :#{method}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dsu/views/shared/model_errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+
+module Dsu
+  module Views
+    module Shared
+      class ModelErrors < Error
+        def initialize(model:, options: {})
+          raise ArgumentError, 'model is nil' if model.nil?
+          raise ArgumentError, "model is the wrong object type: \"#{model}\"" unless model.is_a?(ActiveModel::Model)
+
+          header = options[:header] || 'The following ERRORS were encountered; changes could not be saved:'
+          super(messages: model.errors.full_messages, header: header, options: options)
+
+          @model = model
+        end
+
+        def render
+          return if model.valid?
+
+          super
+        end
+
+        private
+
+        attr_reader :model
+      end
+    end
+  end
+end

data/lib/dsu/views/shared/success.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'message'
+
+module Dsu
+  module Views
+    module Shared
+      class Success < Message
+        def initialize(messages:, header: nil, options: {})
+          options = { header: header, output_stream: $stdout }.merge(options)
+
+          super(messages: messages, message_type: :success, options: options)
+        end
+      end
+    end
+  end
+end

data/lib/dsu/views/shared/warning.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'message'
+
+module Dsu
+  module Views
+    module Shared
+      class Warning < Message
+        def initialize(messages:, header: nil, options: {})
+          options = { header: header, output_stream: $stdout }.merge(options)
+
+          super(messages: messages, message_type: :warning, options: options)
+        end
+      end
+    end
+  end
+end