dsu 1.2.1 → 2.0.1

data/lib/dsu/models/migration_version.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require_relative '../crud/json_file'
+require_relative '../services/migration_version/hydrator_service'
+require_relative '../validators/version_validator'
+
+module Dsu
+  module Models
+    # This class represents a dsu migration_version.
+    class MigrationVersion < Crud::JsonFile
+      include Support::Fileable
+
+      attr_reader :options
+
+      def initialize(version: nil, options: {})
+        super(migration_version_path)
+
+        FileUtils.mkdir_p migration_version_folder
+
+        @options = options || {}
+        @version = version and return if version
+
+        file_hash = if exist?
+          read do |migration_version_hash|
+            hydrated_hash =
+              Services::MigrationVersion::HydratorService.new(migration_version_hash: migration_version_hash).call
+            migration_version_hash.merge!(hydrated_hash)
+          end
+        end
+
+        self.version = file_hash.try(:[], :version) || 0
+      end
+
+      # Returns true if the current dsu install is the
+      # current migration version.
+      def current_migration?
+        version == Dsu::Migration::VERSION
+      end
+
+      def to_h
+        {
+          version: version
+        }
+      end
+    end
+  end
+end

data/lib/dsu/presenters/base_presenter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'delegate'
+require_relative '../models/color_theme'
+require_relative '../support/color_themable'
+
+module Dsu
+  module Presenters
+    class BasePresenter < SimpleDelegator
+      include Support::ColorThemable
+
+      attr_reader :color_theme
+
+      def initialize(object, options: {})
+        super(object)
+
+        @options = options || {}
+        theme_name = options.fetch(:theme_name, Models::Configuration.new.theme_name)
+        @color_theme = Models::ColorTheme.find(theme_name: theme_name)
+      end
+
+      private
+
+      attr_reader :options
+
+      def formatted_index(index:)
+        apply_theme("#{format('%02s', index + 1)}. ",
+          theme_color: color_theme.index)
+      end
+    end
+  end
+end

data/lib/dsu/presenters/color_theme_presenter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'base_presenter'
+
+module Dsu
+  module Presenters
+    class ColorThemePresenter < BasePresenter
+      attr_reader :color_theme
+
+      def initialize(color_theme, options: {})
+        super
+
+        @color_theme = color_theme
+      end
+
+      def header
+        apply_theme('Color Themes', theme_color: color_theme.subheader)
+      end
+
+      def footer
+        apply_theme('* current theme', theme_color: color_theme.footer)
+      end
+
+      def detail
+        "#{apply_theme(theme_name_formatted, theme_color: color_theme.body)} - " \
+          "#{apply_theme(description, theme_color: color_theme.body)}"
+      end
+
+      def detail_with_index(index:)
+        "#{formatted_index(index: index)} #{detail}"
+      end
+
+      private
+
+      def theme_name_formatted
+        return theme_name unless default_color_theme?
+
+        "*#{theme_name}"
+      end
+
+      def default_color_theme?
+        theme_name == default_color_theme.theme_name
+      end
+
+      def default_color_theme
+        @default_color_theme ||= Models::ColorTheme.current_or_default
+      end
+    end
+  end
+end

data/lib/dsu/presenters/color_theme_show_presenter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'base_presenter'
+
+module Dsu
+  module Presenters
+    class ColorThemeShowPresenter < BasePresenter
+      def initialize(color_theme, options: {})
+        super(color_theme, options: options.merge(theme_name: color_theme.theme_name))
+      end
+
+      def detail
+        puts_detail('No.', 'Color', 'Values', header: true)
+
+        Models::ColorTheme::DEFAULT_THEME_COLORS.keys.each_with_index do |color_key, index|
+          index = formatted_index(index: index)
+          color_hash = color_theme.public_send(color_key)
+          puts_detail(index, color_key, color_hash)
+        end
+      end
+
+      def detail_with_index(index:)
+        "#{formatted_index(index: index)} #{detail}"
+      end
+
+      def footer
+        apply_theme('Footer example', theme_color: color_theme.footer)
+      end
+
+      def header
+        apply_theme("Viewing color theme: #{color_theme.theme_name}", theme_color: color_theme.subheader)
+      end
+
+      private
+
+      def puts_detail(index, color_key, color_hash, header: false)
+        if header
+          puts "#{apply_theme(index.to_s.ljust(4), theme_color: color_theme.index.bold!)} " \
+               "#{apply_theme(color_key.to_s.ljust(15), theme_color: color_theme.index.bold!)} " \
+               "#{apply_theme(color_hash.to_s.ljust(10), theme_color: color_theme.index.bold!)}"
+        else
+          puts "#{apply_theme(index.to_s.ljust(4), theme_color: color_theme.index)} " \
+               "#{apply_theme(color_key.to_s.ljust(15), theme_color: color_hash)} " \
+               "#{apply_theme(color_hash.to_s.ljust(10), theme_color: color_theme.body)}"
+        end
+      end
+    end
+  end
+end

data/lib/dsu/presenters/configuration_presenter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../support/color_themable'
+require_relative 'base_presenter'
+
+module Dsu
+  module Presenters
+    class ConfigurationPresenter < BasePresenter
+      attr_reader :config
+
+      def initialize(config, options: {})
+        super
+
+        @config = config
+      end
+
+      def configuration_header
+        apply_theme("Configuration file contents (#{config_path})",
+          theme_color: color_theme.header)
+      end
+
+      def configuration_details
+        to_h.each_with_index.filter_map do |config_entry, index|
+          formatted_config_entry_with_index(config_entry, index: index, theme_color: color_theme.body)
+        end
+      end
+
+      private
+
+      def config_path
+        @config_path ||= config.file_path
+      end
+
+      def formatted_config_entry_with_index(config_entry, index:, theme_color:)
+        "#{formatted_index(index: index)} #{formatted_config_entry(config_entry: config_entry,
+          theme_color: theme_color)}"
+      end
+
+      def formatted_config_entry(config_entry:, theme_color:)
+        config_entry = "#{config_entry[0]}: '#{config_entry[1]}'"
+        apply_theme(config_entry, theme_color: theme_color)
+      end
+    end
+  end
+end

data/lib/dsu/presenters/entry_group_presenter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../support/time_formatable'
+require_relative 'base_presenter'
+
+module Dsu
+  module Presenters
+    class EntryGroupPresenter < BasePresenter
+      attr_reader :entry_group
+
+      def initialize(entry_group, options: {})
+        super
+
+        @entry_group = entry_group
+      end
+
+      def formatted_time
+        colors = color_theme.date
+        apply_theme(Support::TimeFormatable.formatted_time(time: time), theme_color: colors)
+      end
+
+      def formatted_errors
+        return if valid?
+
+        colors = color_theme.error
+        apply_theme(errors.full_messages.join(', '), theme_color: colors)
+      end
+
+      def no_entries_available
+        colors = color_theme.info
+        apply_theme('(no entries available for this day)', theme_color: colors)
+      end
+    end
+  end
+end

data/lib/dsu/presenters/entry_presenter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'base_presenter'
+
+module Dsu
+  module Presenters
+    class EntryPresenter < BasePresenter
+      attr_reader :entry
+
+      def initialize(entry, options: {})
+        super
+
+        @entry = entry
+      end
+
+      def formatted_description
+        apply_theme(description, theme_color: color_theme.body)
+      end
+
+      def formatted_description_with_index(index:)
+        "#{formatted_index(index: index)} #{formatted_description}"
+      end
+    end
+  end
+end

data/lib/dsu/services/color_theme/hydrator_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../../models/color_theme'
+
+module Dsu
+  module Services
+    module ColorTheme
+      class HydratorService
+        def initialize(theme_name:, theme_hash:, options: {})
+          raise ArgumentError, 'theme_name is nil.' if theme_name.nil?
+          raise ArgumentError, "theme_name is the wrong object type: \"#{theme_name}\"." unless theme_hash.is_a?(Hash)
+          raise ArgumentError, 'theme_hash is nil' if theme_hash.nil?
+          raise ArgumentError, "theme_hash is the wrong object type: \"#{theme_hash}\"" unless theme_hash.is_a?(Hash)
+          raise ArgumentError, 'options is nil' if options.nil?
+          raise ArgumentError, "options is the wrong object type:\"#{options}\"" unless options.is_a?(Hash)
+
+          @theme_name = theme_name
+          @theme_hash = theme_hash
+          @options = options || {}
+        end
+
+        def call
+          Models::ColorTheme.new(theme_name: theme_name, theme_hash: hydrate)
+        end
+
+        private
+
+        attr_reader :theme_hash, :theme_name, :options
+
+        def hydrate
+          theme_hash.each_pair do |key, value|
+            next if %i[version description].include?(key)
+
+            value.each_pair do |k, _v|
+              value[k] = value[k].to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dsu/services/configuration/hydrator_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../../models/configuration'
+require_relative '../../views/shared/message'
+
+module Dsu
+  module Services
+    module Configuration
+      class HydratorService
+        def initialize(config_hash:, options: {})
+          raise ArgumentError, 'config_hash is nil' if config_hash.nil?
+
+          unless config_hash.is_a?(Hash)
+            raise ArgumentError,
+              "config_hash is the wrong object type: \"#{config_hash}\""
+          end
+          raise ArgumentError, 'options is nil' if options.nil?
+          raise ArgumentError, "options is the wrong object type:\"#{options}\"" unless options.is_a?(Hash)
+
+          @config_hash = config_hash.dup
+          @options = options || {}
+        end
+
+        def call
+          hydrate
+        end
+
+        private
+
+        attr_reader :config_hash, :options
+
+        def hydrate
+          config_hash[:version] = config_hash[:version].to_i
+          config_hash[:entries_display_order] = config_hash[:entries_display_order].to_sym
+          config_hash
+        rescue JSON::ParserError => _e
+          Models::Configuration::DEFAULT_CONFIGURATION
+        end
+      end
+    end
+  end
+end

data/lib/dsu/services/entry/hydrator_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../models/entry'
+
+module Dsu
+  module Services
+    module Entry
+      class HydratorService
+        def initialize(entries_array:, options: {})
+          raise ArgumentError, 'entries_array is nil' if entries_array.nil?
+          raise ArgumentError, 'options is nil' if options.nil?
+
+          @entries_array = entries_array
+          @options = options || {}
+        end
+
+        def call
+          hydrate
+        end
+
+        private
+
+        attr_reader :entries_array, :options
+
+        def hydrate
+          entries_array.map do |entry_hash|
+            Dsu::Models::Entry.new(**entry_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dsu/services/entry_group/editor_service.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative '../../models/color_theme'
+require_relative '../../models/entry'
+require_relative '../../support/color_themable'
+require_relative '../../support/time_formatable'
+require_relative '../../views/shared/model_errors'
+require_relative '../stdout_redirector_service'
+require_relative '../temp_file/reader_service'
+require_relative '../temp_file/writer_service'
+
+module Dsu
+  module Services
+    module EntryGroup
+      class EditorService
+        include Support::ColorThemable
+        include Support::TimeFormatable
+
+        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)
+          raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash) || options.nil?
+
+          @entry_group = entry_group
+          @options = options || {}
+        end
+
+        def call
+          edit_view = render_edit_view
+          edit edit_view
+          # NOTE: Return the original entry group object as any permanent changes
+          # will have been applied to it.
+          entry_group
+        end
+
+        private
+
+        attr_reader :entry_group, :options
+
+        # Renders the edit view to a string so we can write it to a temporary file
+        # and edit it. The edits will be used to update the entry group.
+        def render_edit_view
+          puts apply_theme("Editing entry group #{formatted_time(time: entry_group.time)}...",
+            theme_color: color_theme.header)
+          # TODO: Call #render_as_string directly below?
+          StdoutRedirectorService.call { Views::EntryGroup::Edit.new(entry_group: entry_group).render }
+          # Views::EntryGroup::Edit.new(entry_group: entry_group).render_as_string
+        end
+
+        # Writes the temporary file contents to disk and opens it in the editor
+        # for editing. It then copies the changes to the entry group and writes
+        # the changes to the entry group file.
+        def edit(edit_view)
+          entry_group_with_edits = Models::EntryGroup.new(time: entry_group.time)
+
+          TempFile::WriterService.new(tmp_file_content: edit_view).call do |tmp_file_path|
+            if Kernel.system("${EDITOR:-#{configuration.editor}} #{tmp_file_path}")
+              TempFile::ReaderService.new(tmp_file_path: tmp_file_path).call do |editor_line|
+                next unless process_description?(editor_line)
+
+                entry_group_with_edits.entries << Models::Entry.new(description: editor_line)
+              end
+
+              process_entry_group!(entry_group_with_edits)
+            else
+              puts apply_theme(
+                [
+                  "Failed to open temporary file in editor '#{configuration.editor}'; " \
+                  "the system error returned was: '#{$CHILD_STATUS}'.",
+                  'Either set the EDITOR environment variable ' \
+                  'or set the dsu editor configuration option (`$ dsu config info`).',
+                  'Run `$ dsu help config` for more information.'
+                ], theme_color: color_theme.error
+              )
+            end
+          end
+        end
+
+        def process_entry_group!(entry_group_with_edits)
+          if entry_group_with_edits.entries.empty?
+            entry_group.delete
+            return
+          end
+
+          Views::Shared::ModelErrors.new(model: entry_group_with_edits).render if entry_group_with_edits.invalid?
+
+          # Make sure we're saving only valid, unique entries.
+          entry_group.entries = entry_group_with_edits.valid_unique_entries
+          entry_group.save!
+        end
+
+        def process_description?(description)
+          description = Models::Entry.clean_description(description)
+          !(description.blank? || description[0] == '#')
+        end
+
+        def color_theme
+          @color_theme ||= Models::ColorTheme.current_or_default
+        end
+
+        def configuration
+          Models::Configuration.new
+        end
+      end
+    end
+  end
+end

data/lib/dsu/services/entry_group/hydrator_service.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../models/entry_group'
+require_relative '../entry/hydrator_service'
+
+module Dsu
+  module Services
+    module EntryGroup
+      class HydratorService
+        def initialize(entry_group_hash:, options: {})
+          raise ArgumentError, 'entry_group_hash is nil' if entry_group_hash.nil?
+          raise ArgumentError, 'options is nil' if options.nil?
+
+          @entry_group_hash = entry_group_hash
+          @options = options || {}
+        end
+
+        def call
+          Models::EntryGroup.new(**hydrate)
+        end
+
+        private
+
+        attr_reader :entry_group_hash, :options
+
+        # Returns a Hash with :time and :entries values hydrated (i.e. Time and Entry objects respectively).
+        def hydrate
+          entry_group_hash.tap do |hash|
+            hash[:time] = Time.parse(hash[:time])
+            hash[:entries] =
+              Entry::HydratorService.new(entries_array: hash[:entries], options: options).call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dsu/services/migration_version/hydrator_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Services
+    module MigrationVersion
+      class HydratorService
+        def initialize(migration_version_hash:, options: {})
+          raise ArgumentError, 'migration_version_hash is nil' if migration_version_hash.nil?
+
+          unless migration_version_hash.is_a?(Hash)
+            raise ArgumentError,
+              "migration_version_hash is the wrong object type: \"#{migration_version_hash}\""
+          end
+          raise ArgumentError, 'options is nil' if options.nil?
+          raise ArgumentError, "options is the wrong object type:\"#{options}\"" unless options.is_a?(Hash)
+
+          @migration_version_hash = migration_version_hash.dup
+          @options = options || {}
+        end
+
+        def call
+          hydrate
+        end
+
+        private
+
+        attr_reader :migration_version_hash, :options
+
+        def hydrate
+          migration_version_hash[:version] = migration_version_hash[:version].to_i
+          migration_version_hash
+        end
+      end
+    end
+  end
+end

data/lib/dsu/services/stderr_redirector_service.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Services
+    # This service captures $stderr, resirects it to a StringIO object,
+    # and returns the string value.
+    # https://stackoverflow.com/questions/4459330/how-do-i-temporarily-redirect-stderr-in-ruby/4459463#4459463
+    module StderrRedirectorService
+      class << self
+        def call
+          raise ArgumentError, 'no block was provided' unless block_given?
+
+          # The output stream must be an IO-like object. In this case we capture it in
+          # an in-memory IO object so we can return the string value. Any IO object can
+          # be used here.
+          string_io = StringIO.new
+          original_stderr, $stderr = $stderr, string_io # rubocop:disable Style/ParallelAssignment
+          yield
+          string_io.string
+        ensure
+          # Restore the original $stderr.
+          $stderr = original_stderr
+        end
+      end
+    end
+  end
+end

data/lib/dsu/services/temp_file/reader_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Services
+    module TempFile
+      class ReaderService
+        def initialize(tmp_file_path:, options: {})
+          raise ArgumentError, 'tmp_file_path is nil' if tmp_file_path.nil?
+          raise ArgumentError, 'tmp_file_path is the wrong object type' unless tmp_file_path.is_a?(String)
+          raise ArgumentError, 'tmp_file_path is empty' if tmp_file_path.empty?
+          raise ArgumentError, 'tmp_file_path does not exist' unless File.exist?(tmp_file_path)
+          raise ArgumentError, 'options is nil' if options.nil?
+          raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash)
+
+          @tmp_file_path = tmp_file_path
+          @options = options || {}
+        end
+
+        def call
+          raise ArgumentError, 'no block given' unless block_given?
+
+          File.foreach(tmp_file_path) do |line|
+            yield line.strip
+          end
+        end
+
+        private
+
+        attr_reader :tmp_file_path, :options
+      end
+    end
+  end
+end

data/lib/dsu/services/temp_file/writer_service.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module Dsu
+  module Services
+    module TempFile
+      class WriterService
+        def initialize(tmp_file_content:, options: {})
+          raise ArgumentError, 'tmp_file_content is nil' if tmp_file_content.nil?
+          raise ArgumentError, 'tmp_file_content is the wrong object type' unless tmp_file_content.is_a?(String)
+          raise ArgumentError, 'options is nil' if options.nil?
+          raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash)
+
+          @tmp_file_content = tmp_file_content
+          @options = options || {}
+        end
+
+        def call
+          raise ArgumentError, 'no block given' unless block_given?
+
+          Tempfile.new('dsu').tap do |file|
+            file.write("#{tmp_file_content}\n")
+            file.close
+            yield file.path
+          end.unlink
+        end
+
+        private
+
+        attr_reader :tmp_file_content, :options
+      end
+    end
+  end
+end