dsu 2.4.4 → 3.0.0.alpha.0

data/lib/dsu/subcommands/export.rb

@@ -23,7 +23,8 @@ module Dsu
       long_desc I18n.t('subcommands.export.all.long_desc')
       option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
       def all
-        Views::Export.new(presenter: all_presenter(options: options)).render
+        options = configuration.to_h.merge(self.options).with_indifferent_access
+        Views::Export.new(presenter: all_presenter(options: options), options: options).render
       end
 
       desc I18n.t('subcommands.export.dates.desc'), I18n.t('subcommands.export.dates.usage')
@@ -41,7 +42,8 @@ module Dsu
           return
         end
 
-        Views::Export.new(presenter: dates_presenter_for(from: times.min, to: times.max, options: options)).render
+        Views::Export.new(presenter:
+          dates_presenter_for(from: times.min, to: times.max, options: options), options: options).render
       rescue ArgumentError => e
         Views::Shared::Error.new(messages: e.message).render
       end

data/lib/dsu/subcommands/import.rb

@@ -6,6 +6,7 @@ require_relative '../support/command_options/dsu_times'
 require_relative '../support/command_options/time_mnemonic'
 require_relative '../support/time_formatable'
 require_relative '../views/import'
+require_relative '../views/import_dates'
 require_relative '../views/shared/error'
 require_relative 'base_subcommand'
 
@@ -23,10 +24,12 @@ module Dsu
       long_desc I18n.t('subcommands.import.all.long_desc')
       option :import_file, type: :string, required: true, aliases: '-i', banner: 'IMPORT_CVS_FILE'
       option :merge, type: :boolean, default: true, aliases: '-m'
+      option :override, type: :boolean, default: false, aliases: '-o'
       option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
       def all
+        options = configuration.to_h.merge(self.options).with_indifferent_access
         Views::Import.new(presenter: all_presenter(import_file_path: options[:import_file],
-          options: options)).render
+          options: options), options: options).render
       end
 
       desc I18n.t('subcommands.import.dates.desc'), I18n.t('subcommands.import.dates.usage')
@@ -37,6 +40,7 @@ module Dsu
       option :to, type: :string, required: true, aliases: '-t', banner: 'DATE|MNEMONIC'
       option :import_file, type: :string, required: true, aliases: '-i', banner: 'IMPORT_CVS_FILE'
       option :merge, type: :boolean, default: true, aliases: '-m'
+      option :override, type: :boolean, default: false, aliases: '-o'
       option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
       def dates
         options = configuration.to_h.merge(self.options).with_indifferent_access
@@ -46,10 +50,10 @@ module Dsu
           return
         end
 
-        Views::Import.new(presenter: dates_presenter_for(from: times.min,
+        Views::ImportDates.new(presenter: dates_presenter_for(from: times.min,
           to: times.max,
           import_file_path: options[:import_file],
-          options: options)).render
+          options: options), options: options).render
       rescue ArgumentError => e
         Views::Shared::Error.new(messages: e.message).render
       end

data/lib/dsu/subcommands/project.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative '../presenters/project/create_presenter'
+require_relative '../presenters/project/delete_presenter'
+require_relative '../presenters/project/list_presenter'
+require_relative '../presenters/project/use_by_number_presenter'
+require_relative '../presenters/project/use_presenter'
+require_relative '../views/project/create'
+require_relative '../views/project/use'
+require_relative '../views/project/use_by_number'
+require_relative '../views/shared/error'
+require_relative 'base_subcommand'
+
+module Dsu
+  module Subcommands
+    class Project < BaseSubcommand
+      # TODO: I18n.
+      map %w[c] => :create
+      map %w[d] => :delete
+      map %w[l] => :list
+      map %w[r] => :rename
+      map %w[u] => :use
+
+      desc I18n.t('subcommands.project.create.desc'), I18n.t('subcommands.project.create.usage')
+      long_desc I18n.t('subcommands.project.create.long_desc')
+      option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
+      def create(project_name = nil, description = nil)
+        project_name = project_name.to_s.strip
+        description = description.to_s.strip
+        if project_name.blank?
+          return Views::Shared::Error.new(
+            messages: I18n.t('subcommands.project.messages.project_name_blank')
+          ).render
+        end
+
+        options = configuration.to_h.merge(self.options).with_indifferent_access
+        presenter = Presenters::Project::CreatePresenter.new(project_name: project_name,
+          description: description, options: options)
+        Views::Project::Create.new(presenter: presenter, options: options).render
+      end
+
+      desc I18n.t('subcommands.project.delete.desc'), I18n.t('subcommands.project.delete.usage')
+      long_desc I18n.t('subcommands.project.delete.long_desc')
+      option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
+      def delete(project_name_or_number = nil)
+        options = configuration.to_h.merge(self.options).with_indifferent_access
+        presenter = delete_presenter_for(project_name_or_number, options: options)
+        delete_view_for(project_name_or_number, presenter: presenter, options: options).render
+      end
+
+      desc I18n.t('subcommands.project.list.desc'), I18n.t('subcommands.project.list.usage')
+      long_desc I18n.t('subcommands.project.list.long_desc')
+      option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
+      def list
+        options = configuration.to_h.merge(self.options).with_indifferent_access
+        presenter = Presenters::Project::ListPresenter.new(options: options)
+        Views::Project::List.new(presenter: presenter, options: options).render
+      end
+
+      desc I18n.t('subcommands.project.rename.desc'), I18n.t('subcommands.project.rename.usage')
+      long_desc I18n.t('subcommands.project.rename.long_desc')
+      option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
+      def rename(project_name_or_number = nil, new_project_name = nil, new_project_description = nil)
+        project_name_or_number = project_name_or_number.to_s.strip
+        new_project_name = new_project_name&.to_s&.strip
+        new_project_description = new_project_description&.to_s&.strip
+
+        if new_project_name.blank?
+          return Views::Shared::Error.new(
+            messages: I18n.t('subcommands.project.messages.new_project_name_blank')
+          ).render
+        end
+
+        options = configuration.to_h.merge(self.options).with_indifferent_access
+        presenter = rename_presenter_for(project_name_or_number, new_project_name: new_project_name,
+          new_project_description: new_project_description, options: options)
+        rename_view_for(project_name_or_number, presenter: presenter, options: options).render
+      end
+
+      desc I18n.t('subcommands.project.use.desc'), I18n.t('subcommands.project.use.usage')
+      long_desc I18n.t('subcommands.project.use.long_desc')
+      option :prompts, type: :hash, default: {}, hide: true, aliases: '-p'
+      def use(project_name_or_number = nil)
+        options = configuration.to_h.merge(self.options).with_indifferent_access
+        presenter = use_presenter_for(project_name_or_number, options: options)
+        use_view_for(project_name_or_number, presenter: presenter, options: options).render
+      end
+
+      private
+
+      def delete_view_for(project_name, presenter:, options:)
+        if project_number?(project_name)
+          Views::Project::DeleteByNumber.new(presenter: presenter, options: options)
+        else
+          Views::Project::Delete.new(presenter: presenter, options: options)
+        end
+      end
+
+      def delete_presenter_for(project_name, options:)
+        if project_number?(project_name)
+          Presenters::Project::DeleteByNumberPresenter.new(project_number: project_name.to_i, options: options)
+        else
+          project_name = Models::Project.default_project_name if project_name.blank?
+          Presenters::Project::DeletePresenter.new(project_name: project_name, options: options)
+        end
+      end
+
+      def rename_view_for(project_name, presenter:, options:)
+        if project_number?(project_name)
+          Views::Project::RenameByNumber.new(presenter: presenter, options: options)
+        else
+          Views::Project::Rename.new(presenter: presenter, options: options)
+        end
+      end
+
+      def rename_presenter_for(project_name, new_project_name:, new_project_description:, options:)
+        if project_number?(project_name)
+          Presenters::Project::RenameByNumberPresenter.new(project_number: project_name.to_i,
+            new_project_name: new_project_name, new_project_description: new_project_description, options: options)
+        else
+          project_name = Models::Project.default_project_name if project_name.blank?
+          Presenters::Project::RenamePresenter.new(project_name: project_name,
+            new_project_name: new_project_name, new_project_description: new_project_description, options: options)
+        end
+      end
+
+      def use_view_for(project_name, presenter:, options:)
+        if project_number?(project_name)
+          Views::Project::UseByNumber.new(presenter: presenter, options: options)
+        else
+          Views::Project::Use.new(presenter: presenter, options: options)
+        end
+      end
+
+      def use_presenter_for(project_name, options:)
+        if project_number?(project_name)
+          Presenters::Project::UseByNumberPresenter.new(project_number: project_name.to_i, options: options)
+        else
+          project_name = Models::Project.default_project_name if project_name.blank?
+          Presenters::Project::UsePresenter.new(project_name: project_name, options: options)
+        end
+      end
+
+      def project_number?(project_name)
+        /^[+-]?\d+(\.\d+)?$/.match?(project_name.to_s)
+      end
+    end
+  end
+end

data/lib/dsu/support/ask.rb

@@ -1,13 +1,20 @@
 # frozen_string_literal: true
 
+require 'io/console'
 require 'thor'
 
 module Dsu
   module Support
     module Ask
-      def ask(prompt)
-        options = {}
-        Thor::LineEditor.readline(prompt, options)
+      def ask_while(prompt, options: {}) # rubocop:disable Lint/UnusedMethodArgument
+        loop do
+          print prompt
+          char = $stdin.getch
+          puts char
+          return char if yield(char)
+
+          char
+        end
       end
 
       def yes?(prompt, options: {})

data/lib/dsu/support/color_themable.rb

@@ -8,7 +8,7 @@ module Dsu
       def prompt_with_options(prompt:, options:)
         # HACK: This module needs to be refactored to be more generic.
         target_color_theme = defined?(color_theme) ? color_theme : self
-        options = "[#{options.join('/')}]"
+        options = "[#{options.join(',')}]"
         "#{apply_theme(prompt, theme_color: target_color_theme.prompt)} " \
           "#{apply_theme(options, theme_color: target_color_theme.prompt_options)}" \
           "#{apply_theme('>', theme_color: target_color_theme.prompt)}"

data/lib/dsu/support/command_hookable.rb

@@ -2,6 +2,7 @@
 
 require_relative '../env'
 require_relative '../models/color_theme'
+require_relative '../models/project'
 require_relative '../services/stderr_redirector_service'
 require_relative '../views/shared/error'
 require_relative 'color_themable'
@@ -34,14 +35,18 @@ module Dsu
         end
 
         def display_dsu_footer
-          puts apply_theme('_' * 35, theme_color: color_theme.dsu_footer)
+          puts apply_theme('_' * 50, theme_color: color_theme.dsu_footer)
           # TODO: I18n.
-          puts apply_theme("dsu | Version: #{Dsu::VERSION} | Theme: #{color_theme.theme_name}",
+          puts apply_theme("dsu v#{Dsu::VERSION} | Project: #{project} | Theme: #{color_theme.theme_name}",
             theme_color: color_theme.dsu_footer)
         end
 
         private
 
+        def project
+          Models::Project.current_project_name
+        end
+
         def suspend_header?(args, _options)
           return false unless args.count > 1
 

data/lib/dsu/support/descriptable.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'short_string'
+
 module Dsu
   module Support
     module Descriptable
-      DESCRIPTION_MAX_COUNT = 25
-
       class << self
         def included(base)
           base.extend(ClassMethods)
@@ -18,26 +18,10 @@ module Dsu
       end
 
       module ClassMethods
-        def short_description(string:, count: DESCRIPTION_MAX_COUNT, elipsis: '...')
-          return elipsis unless string.is_a?(String)
-
-          elipsis_length = elipsis.length
-          count = elipsis_length if count.nil? || count < elipsis_length
-
-          return string if string.length <= count
-
-          tokens = string.split
-          string = ''
-
-          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
-
-            string = "#{string} #{token}"
-          end
+        include ShortString
 
-          "#{string.strip}#{elipsis}"
+        def short_description(string:, count: ShortString::SHORT_STRING_MAX_COUNT, elipsis: '...')
+          short_string(string: string, count: count, elipsis: elipsis)
         end
       end
     end

data/lib/dsu/support/fileable.rb

@@ -26,7 +26,8 @@ module Dsu
       # Entries
 
       def entries_folder
-        File.join(dsu_folder, 'entries')
+        project_folder = project_folder_for(project_name: Models::Project.current_project_name)
+        File.join(project_folder, 'entries')
       end
 
       def entries_file_name(time:, file_name_format: nil)
@@ -88,6 +89,43 @@ module Dsu
         File.join(gem_dir, 'lib/seed_data')
       end
 
+      # Projects
+
+      # Returns the folder where all the projects are stored.
+      def projects_folder
+        File.join(dsu_folder, 'projects')
+      end
+
+      # Current project
+
+      # Contains the name of the file that contains the current
+      # dsu project currently being used.
+      def current_project_file_name
+        'current_project.json'
+      end
+
+      # The complete path to the current project file.
+      def current_project_file
+        File.join(dsu_folder, current_project_file_name)
+      end
+
+      # Project helpers
+
+      # Returns the path of the project with the given name.
+      def project_folder_for(project_name:)
+        raise I18n.t('errors.project_name_invalid', project_name: '{{blank}}') if project_name.blank?
+
+        File.join(projects_folder, project_name)
+      end
+      alias project_folder project_folder_for
+
+      def project_file_for(project_name:)
+        project_folder = project_folder_for(project_name: project_name)
+
+        File.join(project_folder, 'project.json')
+      end
+      alias project_file project_file_for
+
       extend self # rubocop:disable Style/ModuleFunction
     end
   end

data/lib/dsu/support/project_file_system.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+require_relative '../crud/json_file'
+require_relative '../migration/version'
+require_relative '../models/configuration'
+require_relative 'fileable'
+
+module Dsu
+  module Support
+    module ProjectFileSystem
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+        end
+      end
+
+      def exist?
+        self.class.project_file_exist?(project_name: project_name)
+      end
+      alias persisted? exist?
+
+      def project_initialized?
+        self.class.project_initialized?(project_name: project_name)
+      end
+
+      def project_number
+        self.class.project_number_for(project_name: project_name)
+      end
+
+      module ClassMethods
+        include Fileable
+
+        # Returns the currently selected (used) project name
+        # from dsu/current_project.json
+        def current_project_name
+          Crud::JsonFile.read!(file_path: current_project_file).fetch(:project_name)
+        end
+
+        def default_project_name
+          Models::Configuration.new.default_project
+        end
+
+        def initialize_project(project_name:)
+          return if project_initialized?(project_name: project_name)
+
+          # TODO: Don't know if I like this here.
+          unless current_project_file_exist?
+            file_data = {
+              version: Dsu::Migration::VERSION,
+              project_name: default_project_name
+            }
+            Crud::JsonFile.write!(file_data: file_data, file_path: current_project_file)
+          end
+
+          # Creates dsu/projects/<project_name>
+          FileUtils.mkdir_p(project_folder_for(project_name: project_name))
+        end
+
+        def project_initialized?(project_name:)
+          # Checking these files, checks all the containing folders also
+          current_project_file_exist? &&
+            project_folder_exist?(project_name: project_name)
+        end
+
+        # Does dsu/projects/<project_name>/project.json file exist?
+        def project_file_exist?(project_name:)
+          project_file_path = project_file_for(project_name: project_name)
+          File.exist?(project_file_path)
+        end
+        alias exist? project_file_exist?
+        alias persisted? project_file_exist?
+
+        # Does dsu/current_project.json file exist?
+        def current_project_file_exist?
+          File.exist?(current_project_file)
+        end
+        alias current_project_file_persisted? current_project_file_exist?
+
+        # Does dsu/projects folder exist?
+        def projects_folder_exist?
+          Dir.exist?(projects_folder)
+        end
+
+        # Does dsu/projects/<project_name> folder exist?
+        def project_folder_exist?(project_name:)
+          Dir.exist?(project_folder_for(project_name: project_name))
+        end
+
+        def project_metadata
+          project_folder_names.each_with_index.with_object([]) do |(project_name, index), array|
+            array << {
+              project_number: index + 1,
+              project_name: project_name,
+              current_project: project_name == current_project_name,
+              default_projet: project_name == default_project_name
+            }
+          end
+        end
+
+        def project_number_for(project_name:)
+          project_metadata.find do |metadata|
+            metadata[:project_name] == project_name
+          end&.[](:project_number) || -1
+        end
+
+        private
+
+        def project_folder_names
+          Pathname.new(projects_folder)
+            .children
+            .select(&:directory?)
+            .map(&:basename)
+            .map(&:to_s)
+            .sort { |a, b| a.casecmp(b) }
+        end
+      end
+    end
+  end
+end

data/lib/dsu/support/short_string.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module ShortString
+      SHORT_STRING_MAX_COUNT = 25
+
+      module_function
+
+      def short_string(string:, count: SHORT_STRING_MAX_COUNT, elipsis: '...')
+        return '' if string.blank?
+        return string if string.length <= count
+
+        # Trim to max count and cut at the last space within the limit
+        trimmed_string = string[0...count].rpartition(' ')[0]
+
+        # If no space found, trim by characters
+        trimmed_string = string[0...(count - elipsis.length)] if trimmed_string.empty? && !string.empty?
+
+        "#{trimmed_string}#{elipsis}"
+      end
+    end
+  end
+end

data/lib/dsu/support/time_comparable.rb

@@ -5,6 +5,8 @@ module Dsu
     module TimeComparable
       TIME_COMPARABLE_FORMAT_SPECIFIER = '%Y%m%d'
 
+      module_function
+
       def time_equal?(other_time:)
         time_equal_compare_string_for(time: time) == time_equal_compare_string_for(time: other_time)
       end

data/lib/dsu/support/transform_project_name.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module TransformProjectName
+      TRANSFORM_PROJECT_NAME_REGEX = %r{[^/\w\s]|_}
+      TRANSFORM_PROJECT_NAME_SEPARATOR = '-'
+
+      module_function
+
+      def transform_project_name(project_name, options: {})
+        normalized_name = project_name
+          .gsub(TRANSFORM_PROJECT_NAME_REGEX, ' ')   # Replace non-word characters and underscores with space
+          .strip                                     # Remove leading and trailing spaces
+          .squeeze(' ')                              # Convert consecutive spaces to a single space
+          .tr(' ', TRANSFORM_PROJECT_NAME_SEPARATOR) # Replace spaces with hyphens
+          .squeeze(TRANSFORM_PROJECT_NAME_SEPARATOR) # Ensure no consecutive hyphens
+
+        normalized_name.downcase! if options[:downcase]
+        normalized_name
+      end
+    end
+  end
+end

data/lib/dsu/validators/project_name_validator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../support/field_errors'
+require_relative '../support/short_string'
+
+# https://guides.rubyonrails.org/active_record_validations.html#validates-with
+module Dsu
+  module Validators
+    # TODO: I18n.
+    class ProjectNameValidator < ActiveModel::Validator
+      include Support::FieldErrors
+      include Support::ShortString
+
+      def validate(record)
+        unless record.project_name.is_a?(String)
+          record.errors.add(:project_name, 'is the wrong object type. ' \
+                                           "\"String\" was expected, but \"#{record.project.class}\" was received.")
+          return
+        end
+
+        unless record.project_name.present?
+          record.errors.add(:project_name, :blank, '')
+
+          return
+        end
+
+        validate_project_name record
+      end
+
+      private
+
+      def validate_project_name(record)
+        project_name = record.project_name
+
+        return if project_name.length.between?(min_project_name_length(record), max_project_name_length(record))
+
+        if project_name.length < min_project_name_length(record)
+          # TODO: I18n.
+          record.errors.add(:project_name, "is too short: \"#{record.project_name}\" " \
+                                           "(minimum is #{min_project_name_length(record)} characters).")
+        elsif project_name.length > max_project_name_length(record)
+          # TODO: I18n.
+          short_project_name = short_string(string: project_name, count: max_project_name_length(record))
+          record.errors.add(:project_name, "is too long: \"#{short_project_name}\" " \
+                                           "(maximum is #{max_project_name_length(record)} characters).")
+        end
+      end
+
+      def min_project_name_length(record)
+        record.class::MIN_PROJECT_NAME_LENGTH
+      end
+
+      def max_project_name_length(record)
+        record.class::MAX_PROJECT_NAME_LENGTH
+      end
+    end
+  end
+end

data/lib/dsu/version.rb

@@ -2,5 +2,5 @@
 
 module Dsu
   VERSION_REGEX = /\A\d+\.\d+\.\d+(\.(alpha|rc)\.\d+)?\z/
-  VERSION = '2.4.4'
+  VERSION = '3.0.0.alpha.0'
 end

data/lib/dsu/views/base_list_view.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../env'
+require_relative '../models/color_theme'
+require_relative '../support/color_themable'
+
+module Dsu
+  module Views
+    class BaseListView
+      include Support::ColorThemable
+
+      attr_reader :presenter
+
+      def initialize(presenter:, options: {})
+        @presenter = presenter
+        @options = options&.dup || {}
+        @color_theme = Models::ColorTheme.find(theme_name: theme_name)
+      end
+
+      def render
+        yield
+      rescue StandardError => e
+        puts apply_theme(e.message, theme_color: color_theme.error)
+        puts apply_theme(e.backtrace_locations.join("\n"), theme_color: color_theme.error) if Dsu.env.local?
+      end
+
+      private
+
+      attr_reader :color_theme, :options
+
+      def theme_name
+        @theme_name ||= options.fetch(:theme_name, Models::Configuration.new.theme_name)
+      end
+
+      def formatted_index(index:)
+        apply_theme("#{format('%02s', index + 1)}. ",
+          theme_color: color_theme.index)
+      end
+    end
+  end
+end