doto 0.0.1.pre.alpha.1

data/lib/doto/support/project_file_system.rb

@@ -0,0 +1,118 @@
+# 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 Doto
+  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 doto/current_project.json
+        def current_project_name
+          Crud::JsonFile.read!(file_path: current_project_file).fetch(:project_name)
+        end
+
+        def default_project_name
+          return Models::Configuration::DEFAULT_CONFIGURATION[:default_project] unless Models::Configuration.exist?
+
+          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: Doto::Migration::VERSION,
+              project_name: default_project_name
+            }
+            Crud::JsonFile.write!(file_data: file_data, file_path: current_project_file)
+          end
+
+          # Creates doto/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 doto/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 doto/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 doto/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/doto/support/short_string.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Doto
+  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/doto/support/time_comparable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Doto
+  module Support
+    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
+
+      def time_equal_compare_string_for(time:)
+        time = time.in_time_zone
+
+        time.strftime(TIME_COMPARABLE_FORMAT_SPECIFIER)
+      end
+    end
+  end
+end

data/lib/doto/support/time_formatable.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'active_support/core_ext/numeric/time'
+
+module Doto
+  module Support
+    # This module provides functions for formatting Time objects
+    # to display in the console.
+    module TimeFormatable
+      module_function
+
+      # TODO: I18n.
+      def formatted_time(time:)
+        time = time.in_time_zone
+
+        today_yesterday_or_tomorrow = if time.today?
+          'Today'
+        elsif time.yesterday?
+          'Yesterday'
+        elsif time.tomorrow?
+          'Tomorrow'
+        end
+
+        time_zone = timezone_for(time: time)
+
+        return time.strftime("%A, %Y-%m-%d #{time_zone}") unless today_yesterday_or_tomorrow
+
+        time.strftime("%A, (#{today_yesterday_or_tomorrow}) %Y-%m-%d #{time_zone}")
+      end
+
+      # TODO: I18n.
+      def mm_dd(time:, separator: '/')
+        time.strftime("%m#{separator}%d")
+      end
+
+      # TODO: I18n.
+      def mm_dd_yyyy(time:, separator: '/')
+        time.strftime("%m#{separator}%d#{separator}%Y")
+      end
+
+      def dd_mm_yyyy(time:, separator: '/')
+        time.strftime("%d#{separator}%m#{separator}%Y")
+      end
+
+      def timezone_for(time:)
+        time.zone
+      end
+
+      # TODO: I18n.
+      def yyyy_mm_dd_or_through_for(times:)
+        return yyyy_mm_dd(time: times[0]) if times.one?
+
+        times = [yyyy_mm_dd(time: times.min), yyyy_mm_dd(time: times.max)]
+
+        I18n.t('information.dates.through', from: times[0], to: times[1])
+      end
+
+      # TODO: I18n.
+      def yyyy_mm_dd(time:, separator: '-')
+        time.strftime("%Y#{separator}%m#{separator}%d")
+      end
+    end
+  end
+end

data/lib/doto/support/times_sortable.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Doto
+  module Support
+    module TimesSortable
+      def sorted_doto_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)
+        times = times.dup
+        entries_display_order ||= :asc
+
+        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.
+        return times.sort if entries_display_order == :asc
+
+        times.sort_by { |time| -time.to_i }
+      end
+
+      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 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?
+
+          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/doto/support/transform_project_name.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Doto
+  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/doto/support/utils.rb

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

data/lib/doto/validators/color_theme_validator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'colorize'
+
+# rubocop:disable Layout/LineLength
+module Doto
+  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/doto/validators/description_validator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Doto
+  module Validators
+    class DescriptionValidator < ActiveModel::Validator
+      def validate(record)
+        description = record.description
+
+        if description.blank?
+          record.errors.add(:description, :blank)
+          return
+        end
+
+        unless description.is_a?(String)
+          # TODO: I18n.
+          record.errors.add(:description, 'is the wrong object type. ' \
+                                          "\"String\" was expected, but \"#{description.class}\" was received.")
+          return
+        end
+
+        validate_description record
+      end
+
+      private
+
+      def validate_description(record)
+        description = record.description
+
+        return if description.length.between?(min_description_length(record), max_description_length(record))
+
+        if description.length < min_description_length(record)
+          # TODO: I18n.
+          record.errors.add(:description, "is too short: \"#{record.short_description}\" " \
+                                          "(minimum is #{min_description_length(record)} characters).")
+        elsif description.length > max_description_length(record)
+          # TODO: I18n.
+          record.errors.add(:description, "is too long: \"#{record.short_description}\" " \
+                                          "(maximum is #{max_description_length(record)} characters).")
+        end
+      end
+
+      def min_description_length(record)
+        record.class::MIN_DESCRIPTION_LENGTH
+      end
+
+      def max_description_length(record)
+        record.class::MAX_DESCRIPTION_LENGTH
+      end
+    end
+  end
+end

data/lib/doto/validators/entries_validator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative '../models/entry'
+require_relative '../support/field_errors'
+
+# https://guides.rubyonrails.org/active_record_validations.html#validates-with
+module Doto
+  module Validators
+    # TODO: I18n.
+    class EntriesValidator < ActiveModel::Validator
+      include Support::FieldErrors
+
+      def validate(record)
+        unless record.entries.is_a?(Array)
+          record.errors.add(:entries, 'is the wrong object type. ' \
+                                      "\"Array\" was expected, but \"#{record.entries.class}\" was received.")
+          return
+        end
+
+        return if validate_entry_types record
+
+        validate_unique_entry record
+        validate_entries record
+      end
+
+      private
+
+      def validate_entry_types(record)
+        record.entries.each do |entry|
+          next if entry.is_a? Doto::Models::Entry
+
+          record.errors.add(:entries, 'Array element is the wrong object type. ' \
+                                      "\"Entry\" was expected, but \"#{entry.class}\" was received.",
+            type: Support::FieldErrors::FIELD_TYPE_ERROR)
+        end
+
+        record.errors.any?
+      end
+
+      def validate_unique_entry(record)
+        return unless record.entries.is_a? Array
+
+        entry_objects = record.entries.select { |entry| entry.is_a?(Doto::Models::Entry) }
+
+        descriptions = entry_objects.map(&:description)
+        return if descriptions.uniq.length == descriptions.length
+
+        non_unique_descriptions = descriptions.select { |description| descriptions.count(description) > 1 }.uniq
+        non_unique_descriptions.each do |non_unique_description|
+          # TODO: I18n.
+          record.errors.add(:entries,
+            "array contains duplicate entry: \"#{short_description(non_unique_description)}\".",
+            type: Support::FieldErrors::FIELD_DUPLICATE_ERROR)
+        end
+
+        record.errors.any?
+      end
+
+      def validate_entries(record)
+        entries = record.entries
+        return if entries.none?
+
+        entries.each do |entry|
+          next if entry.valid?
+
+          entry.errors.each do |error|
+            record.errors.add(:entries_entry, error.full_message)
+          end
+        end
+      end
+
+      def short_description(description)
+        Models::Entry.short_description(string: description)
+      end
+    end
+  end
+end

data/lib/doto/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 Doto
+  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/doto/validators/time_validator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# https://guides.rubyonrails.org/active_record_validations.html#validates-with
+module Doto
+  module Validators
+    class TimeValidator < ActiveModel::Validator
+      def validate(record)
+        time = record.time
+
+        if time.nil?
+          record.errors.add(:time, :blank)
+          return
+        end
+
+        unless time.is_a?(Time)
+          record.errors.add(:time, 'is the wrong object type. ' \
+                                   "\"Time\" was expected, but \"#{time.class}\" was received.")
+          return
+        end
+
+        record.errors.add(:time, 'is not in localtime format.') unless time == time.in_time_zone
+      end
+    end
+  end
+end

data/lib/doto/validators/version_validator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# https://guides.rubyonrails.org/active_record_validations.html#validates-with
+module Doto
+  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/doto/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Doto
+  VERSION_REGEX = /\A\d+\.\d+\.\d+(\.(alpha|beta|rc)\.\d+)?\z/
+  VERSION = '0.0.1-alpha.1'
+end