dsu 1.2.1 → 2.0.0.alpha.1

data/lib/dsu/cli.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'time'
 require_relative 'base_cli'
 require_relative 'subcommands/config'
 require_relative 'subcommands/edit'
 require_relative 'subcommands/list'
+require_relative 'subcommands/theme'
 
 module Dsu
   # The `dsu` command.
@@ -13,44 +15,41 @@ module Dsu
     map %w[c -c] => :config
     map %w[e -e] => :edit
     map %w[l -l] => :list
+    map %w[t -t] => :theme
+    map %w[v -i] => :info
     map %w[v -v] => :version
 
     desc 'add, -a [OPTIONS] DESCRIPTION',
       'Adds a DSU entry having DESCRIPTION to the date associated with the given OPTION'
     long_desc <<-LONG_DESC
       NAME
-      \x5
-      `dsu add, -a [OPTIONS] DESCRIPTION` -- will add a DSU entry having DESCRIPTION to the date associated with the given OPTION.
+
+      $ dsu add, -a [OPTIONS] DESCRIPTION -- will add a DSU entry having DESCRIPTION to the date associated with the given OPTION.
 
       SYNOPSIS
-      \x5
-      `dsu add, -a [-d DATE|-n|-t|-y] DESCRIPTION`
+
+      $ dsu add, -a [-d DATE|-n|-t|-y] DESCRIPTION
 
       OPTIONS:
-      \x5
+
       -d DATE: Adds a DSU entry having DESCRIPTION to the DATE.
 
-      \x5
       #{date_option_description}
 
-      \x5
       -n: Adds a DSU entry having DESCRIPTION to today's date (`Time.now`).
 
-      \x5
       -t: Adds a DSU entry having DESCRIPTION to tomorrow's date (`Time.new.tomorrow`).
 
-      \x5
       -y: Adds a DSU entry having DESCRIPTION to yesterday's date (`Time.new.yesterday`).
 
       DESCRIPTION:
-      \x5
+
       Must be be between 2 and 256 characters (inclusive) in length.
     LONG_DESC
     option :date, type: :string, aliases: '-d'
     option :tomorrow, type: :boolean, aliases: '-t'
     option :yesterday, type: :boolean, aliases: '-y'
     option :today, type: :boolean, aliases: '-n', default: true
-
     def add(description)
       time = if options[:date].present?
         Time.parse(options[:date])
@@ -66,30 +65,6 @@ module Dsu
       view_entry_group(time: time)
     end
 
-    # def add(description)
-    #   times = if options[:date].present?
-    #     time = Time.parse(options[:date])
-    #     [time, time.yesterday]
-    #   else
-    #     time = Time.now
-    #     if options[:tomorrow].present?
-    #       [time.tomorrow, time.tomorrow.yesterday]
-    #     elsif options[:yesterday].present?
-    #       [time.yesterday, time.yesterday.yesterday]
-    #     elsif options[:today].present?
-    #       [time, time.yesterday]
-    #     end
-    #   end
-    #   entry = Models::Entry.new(description: description)
-    #   # NOTE: We need to add the Entry to the date that is the furthest in the future
-    #   # (time.max) because this is the DSU entry that the user specified.
-    #   CommandServices::AddEntryService.new(entry: entry, time: times.max).call
-    #   sorted_dsu_times_for(times: times).each do |t|
-    #     view_entry_group(time: t)
-    #     puts
-    #   end
-    # end
-
     desc 'list, -l SUBCOMMAND',
       'Displays DSU entries for the given SUBCOMMAND'
     subcommand :list, Subcommands::List
@@ -102,10 +77,45 @@ module Dsu
       'Edit DSU entries for the given SUBCOMMAND'
     subcommand :edit, Subcommands::Edit
 
+    desc 'theme, -t SUBCOMMAND',
+      'Manage DSU themes'
+    subcommand :theme, Subcommands::Theme
+
+    desc 'info, -i',
+      'Displays information about this dsu release'
+    def info
+      configuration_version = Models::Configuration::VERSION
+      entry_group_version = Models::EntryGroup::VERSION
+      color_theme_version = Models::ColorTheme::VERSION
+      info = <<~INFO
+                     Dsu version: #{dsu_version}
+           Configuration version: #{configuration_version}
+             Entry group version: #{entry_group_version}
+             Color theme version: #{color_theme_version}
+
+                     Config path: #{Support::Fileable.config_path}
+                     Root folder: #{Support::Fileable.root_folder}
+                  Entries folder: #{Support::Fileable.entries_folder}
+                   Themes folder: #{Support::Fileable.themes_folder}
+                      Gem folder: #{Support::Fileable.gem_dir}
+                     Temp folder: #{Support::Fileable.temp_folder}
+
+        Migration version folder: #{Support::Fileable.migration_version_folder}
+             Migration file path: #{Support::Fileable.migration_version_path}
+      INFO
+      puts apply_theme(info, theme_color: color_theme.body)
+    end
+
     desc 'version, -v',
-      'Displays this gem version'
+      'Displays the version for this gem'
     def version
-      say VERSION
+      puts apply_theme(dsu_version, theme_color: color_theme.body)
+    end
+
+    private
+
+    def dsu_version
+      "v#{VERSION}"
     end
   end
 end

data/lib/dsu/command_services/add_entry_service.rb

@@ -1,24 +1,19 @@
 # frozen_string_literal: true
 
 require_relative '../models/entry'
-require_relative '../services/entry_group_writer_service'
-require_relative '../support/colorable'
+require_relative '../support/color_themable'
 require_relative '../support/descriptable'
-require_relative '../support/entry_group_loadable'
-require_relative '../support/folder_locations'
-require_relative '../support/say'
-require_relative '../views/shared/messages'
+require_relative '../support/fileable'
+require_relative '../views/shared/error'
 
 module Dsu
   module CommandServices
     # This class adds (does NOT update) an entry to an entry group by
     # writing it to the appropriate entry group json file.
     class AddEntryService
-      include Support::Colorable
+      include Support::ColorThemable
       include Support::Descriptable
-      include Support::EntryGroupLoadable
-      include Support::FolderLocations
-      include Support::Say
+      include Support::Fileable
 
       attr_reader :entry, :entry_group, :time
 
@@ -34,28 +29,22 @@ module Dsu
 
         @entry = entry
         @time = time
-        @entry_group = Models::EntryGroup.load(time: time)
+        @entry_group = Models::EntryGroup.find_or_initialize(time: time)
       end
 
       def call
         entry.validate!
-        save_entry_group!
+        entry_group.entries << entry
+        entry_group.save!
         entry
       rescue ActiveModel::ValidationError => e
-        header = 'An error was encountered; the entry could not be added added:'
-        Views::Shared::Messages.new(messages: e.message, message_type: :error, options: { header: header }).render
+        header = 'An error was encountered; the entry could not be added:'
+        Views::Shared::Error.new(messages: e.message, header: header).render
       end
 
       private
 
       attr_writer :entry, :entry_group, :time
-
-      def save_entry_group!
-        entry_group.entries << entry
-        entry_group.validate!
-
-        Services::EntryGroupWriterService.new(entry_group: entry_group).call
-      end
     end
   end
 end

data/lib/dsu/crud/json_file.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'json'
+require_relative 'raw_json_file'
+
+module Dsu
+  module Crud
+    class JsonFile
+      include ActiveModel::Model
+
+      attr_reader :file_path
+
+      def initialize(file_path)
+        @file_path = file_path
+      end
+
+      def delete
+        self.class.delete(file_path: file_path)
+      end
+
+      def delete!
+        self.class.delete!(file_path: file_path)
+      end
+
+      def exist?
+        self.class.exist?(file_path: file_path)
+      end
+
+      def persisted?
+        exist?
+      end
+
+      # Override this method to reload data from the file
+      def reload
+        @version = read_version
+
+        self
+      end
+
+      def to_h
+        raise NotImplementedError, 'You must implement this method in a your subclass'
+      end
+
+      def to_model
+        self
+      end
+
+      def version
+        @version ||= read_version
+      end
+
+      def write
+        return false unless valid?
+
+        self.class.write(file_data: to_h, file_path: file_path)
+        true
+      end
+
+      def write!
+        validate!
+
+        self.class.write(file_data: to_h, file_path: file_path)
+      end
+
+      alias save write
+      alias save! write!
+
+      class << self
+        def exist?(file_path:)
+          RawJsonFile.exist?(file_path: file_path)
+        end
+
+        def delete(file_path:)
+          RawJsonFile.delete(file_path: file_path)
+        end
+
+        def delete!(file_path:)
+          RawJsonFile.delete!(file_path: file_path)
+        end
+
+        def parse(json)
+          return if json.nil?
+
+          JSON.parse(json, symbolize_names: true)
+        end
+
+        def read(file_path:)
+          hash = parse(RawJsonFile.read(file_path: file_path))
+          return yield hash if hash && block_given?
+
+          hash
+        end
+
+        def read!(file_path:)
+          hash = parse(RawJsonFile.read!(file_path: file_path))
+          return yield hash if hash && block_given?
+
+          hash
+        end
+
+        def write(file_data:, file_path:)
+          Crud::RawJsonFile.write(file_data: file_data, file_path: file_path)
+        end
+
+        def write!(file_data:, file_path:)
+          write(file_data: file_data, file_path: file_path)
+        end
+      end
+
+      private
+
+      def read
+        hash = self.class.parse(RawJsonFile.read(file_path: file_path))
+        return yield hash if block_given?
+
+        hash
+      end
+
+      def read!
+        hash = self.class.parse(RawJsonFile.read!(file_path: file_path))
+        return yield hash if hash && block_given?
+
+        hash
+      end
+
+      def read_version
+        return 0 unless exist?
+
+        hash = read
+        return 0 if hash.nil?
+
+        hash.fetch(:version, 0).to_i
+      end
+
+      attr_writer :file_path, :version
+    end
+  end
+end

data/lib/dsu/crud/raw_json_file.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Dsu
+  module Crud
+    module RawJsonFile
+      class << self
+        def delete(file_path:)
+          return false unless exist?(file_path: file_path)
+
+          File.delete(file_path)
+
+          true
+        end
+
+        def delete!(file_path:)
+          raise file_does_not_exist_message(file_path: file_path) unless delete(file_path: file_path)
+        end
+
+        def exist?(file_path:)
+          File.exist?(file_path)
+        end
+
+        def read(file_path:)
+          File.read(file_path) if exist?(file_path: file_path)
+        end
+
+        def read!(file_path:)
+          raise file_does_not_exist_message(file_path: file_path) unless exist?(file_path: file_path)
+
+          read(file_path: file_path)
+        end
+
+        def write(file_data:, file_path:)
+          raise ArgumentError, 'file_data is nil' if file_data.nil?
+          raise ArgumentError, "file_data is the wrong object type:\"#{file_data}\"" unless file_data.is_a?(Hash)
+
+          file_data = JSON.pretty_generate(file_data)
+          File.write(file_path, file_data)
+        end
+
+        private
+
+        def file_does_not_exist_message(file_path:)
+          "File \"#{file_path}\" does not exist"
+        end
+      end
+    end
+  end
+end

data/lib/dsu/env.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Dsu
+  class << self
+    def env
+      @env ||= Struct.new(:env) do
+        def test?
+          env.fetch('DSU_ENV', nil) == 'test'
+        end
+
+        def development?
+          env.fetch('DSU_ENV', nil) == 'development'
+        end
+
+        def production?
+          env.fetch('DSU_ENV', 'production') == 'production'
+        end
+      end.new(ENV)
+    end
+  end
+end

data/lib/dsu/migration/service.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require_relative '../migration/version'
+require_relative '../models/configuration'
+require_relative '../models/migration_version'
+require_relative '../support/fileable'
+
+module Dsu
+  module Migration
+    MIGRATION_VERSION_REGEX = /(\A\d+)/
+
+    class Service
+      include Support::Fileable
+
+      def initialize(options: {})
+        @options = options || {}
+        @migration_version = Models::MigrationVersion.new(options: options)
+        @start_migration_version = @migration_version.version
+      end
+
+      def call
+        unless self.class.run_migrations?
+          puts 'Nothing to do.'
+          return
+        end
+
+        run_migrations!
+      end
+
+      class << self
+        def run_migrations?
+          Models::MigrationVersion.new.version < Dsu::Migration::VERSION
+        end
+      end
+
+      private
+
+      attr_reader :migration_version, :options, :start_migration_version
+
+      def run_migrations!
+        puts "dsu version: #{Dsu::VERSION}"
+        puts
+
+        puts 'Running migrations...'
+        puts
+
+        puts "Current migration version: #{start_migration_version}"
+        puts "Migrating to version: #{Dsu::Migration::VERSION}"
+        puts
+
+        backup!
+        cleanup!
+        migrate!
+
+        new_migration_version = Models::MigrationVersion.new(version: Dsu::Migration::VERSION).tap(&:save!).version
+
+        puts "Migration version after migration is: #{new_migration_version}"
+        puts 'Migration completed successfully.'
+      rescue StandardError => e
+        warn "Migration completed with errors: #{e.message}"
+      end
+
+      def backup!
+        backup_config!
+        puts
+
+        backup_entry_groups!
+        puts
+
+        backup_themes!
+        puts
+      end
+
+      def backup_config!
+        puts 'Backing up config...'
+        if File.exist?(config_path)
+          backup_path = File.join(current_backup_folder, config_file_name)
+          puts "Backing up #{config_path} to #{backup_path}..."
+          FileUtils.cp(config_path, backup_path)
+        else
+          puts 'No config to backup.'
+        end
+      end
+
+      def backup_entry_groups!
+        puts 'Backing up entry groups...'
+        if Dir.exist?(entries_folder)
+          backup_folder = File.join(current_backup_folder, File.basename(entries_folder))
+          puts "Backing up #{entries_folder} to #{backup_folder}..."
+          FileUtils.mkdir_p(backup_folder)
+          FileUtils.cp_r("#{entries_folder}/.", backup_folder)
+        else
+          puts 'No entries to backup.'
+        end
+      end
+
+      def backup_themes!
+        puts 'Backing up themes...'
+        if Dir.exist?(themes_folder)
+          backup_folder = File.join(current_backup_folder, File.basename(themes_folder))
+          puts "Backing up #{themes_folder} to #{backup_folder}..."
+          FileUtils.mkdir_p(backup_folder)
+          FileUtils.cp_r("#{themes_folder}/.", backup_folder)
+        else
+          puts 'No entries to backup.'
+        end
+      end
+
+      def before_migration_version
+        @before_migration_version ||= migration_version_instance.version
+      end
+
+      def cleanup!
+        puts 'Cleaning up old config file...'
+        File.delete(config_path) if File.file?(config_path)
+        puts 'Done.'
+        puts
+
+        puts 'Cleaning up old entries...'
+        entry_files = Dir.glob(File.join(entries_folder, '*'))
+        entry_files.each do |entry_file|
+          File.delete(entry_file) if File.file?(entry_file)
+        end
+        puts 'Done.'
+        puts
+
+        puts 'Cleaning up old themes...'
+        theme_files = Dir.glob(File.join(themes_folder, '*'))
+        theme_files.each do |theme_file|
+          File.delete(theme_file) if File.file?(theme_file)
+        end
+        puts 'Done.'
+        puts
+      end
+
+      def create_backup_folder!
+        FileUtils.mkdir_p(backup_folder(version: current_migration_version))
+      end
+
+      def current_backup_folder
+        @current_backup_folder ||= begin
+          create_backup_folder!
+          backup_folder(version: current_migration_version)
+        end
+      end
+
+      def current_migration_version
+        migration_version_instance.version
+      end
+
+      # Migrate
+
+      def migrate!
+        FileUtils.mkdir_p(dsu_folder)
+        FileUtils.mkdir_p(themes_folder)
+        FileUtils.mkdir_p(entries_folder)
+
+        migrate_themes!
+        migrate_config!
+        migrate_entry_groups!
+      end
+
+      def migrate_config!
+        puts 'Migrating config...'
+        Models::Configuration.new.save!
+        puts 'Done.'
+      end
+
+      def migrate_entry_groups!
+        puts 'Migrating entry groups...'
+        # source_folder = File.join(seed_data_folder, 'entries')
+        # puts "Copying entries from #{source_folder} to #{entries_folder}..."
+        # FileUtils.cp_r("#{source_folder}/.", entries_folder)
+        # puts 'Done.'
+        description = "Migrated DSU to version #{Dsu::Migration::VERSION}"
+        entry = Models::Entry.new(description: description)
+        Models::EntryGroup.new(time: Time.now, entries: [entry]).save!
+        puts 'Done.'
+      end
+
+      def migrate_themes!
+        puts 'Migrating themes...'
+        source_folder = File.join(seed_data_folder, 'themes')
+        puts "Copying themes from #{source_folder} to #{themes_folder}..."
+        FileUtils.cp_r("#{source_folder}/.", themes_folder)
+        puts 'Done.'
+      end
+
+      def migration_version_instance
+        @migration_version_instance ||= Models::MigrationVersion.new
+      end
+    end
+  end
+end

data/lib/dsu/migration/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Migration
+    VERSION = 20230613121411 # rubocop:disable Style/NumericLiterals
+  end
+end