doto 0.0.1.pre.alpha.1

data/lib/doto/models/configuration.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require_relative '../crud/json_file'
+require_relative '../migration/version'
+require_relative '../support/fileable'
+require_relative '../support/presentable'
+require_relative '../validators/version_validator'
+
+module Doto
+  module Models
+    # This class represents the doto configuration.
+    class Configuration < Crud::JsonFile
+      include Support::Fileable
+      include Support::Presentable
+
+      VERSION = Migration::VERSION
+
+      DEFAULT_CONFIGURATION = {
+        version: VERSION,
+        # The default editor to use when editing entry groups if the EDITOR
+        # environment variable on your system is not set. On nix systmes,
+        # the default editor is`nano`. You need to change this default on
+        # Windows systems.
+        editor: 'nano',
+        # The order by which entries should be displayed by default:
+        # :asc or :desc, ascending or descending, respectively.
+        entries_display_order: :desc,
+        carry_over_entries_to_today: false,
+        # If true, when using doto commands that list date ranges (e.g.
+        # `doto list dates`), the displayed list will include dates that
+        # have no doto entries. If false, the displayed list will only
+        # include dates that have doto entries.
+        # For all other `doto list` commands, if true, this option will
+        # behave in the aforementioned manner. If false, the displayed
+        # list will unconditionally display the first and last dates
+        # regardless of whether or not the TODO date has entries or not;
+        # all other dates will not be displayed if the TODO date has no
+        # entries.
+        include_all: false,
+        # Themes
+        # The currently selected color theme. Should be equal to
+        # Models::ColorTheme::DEFAULT_THEME_NAME or the name of a custom
+        # theme (with the same file name) that resides in the themes_folder.
+        theme_name: 'default',
+        # The default project to use.
+        default_project: 'default'
+      }.freeze
+
+      validates_with Validators::VersionValidator
+      validates :editor, presence: true
+      validates :entries_display_order, presence: true,
+        inclusion: { in: %i[asc desc], message: 'must be :asc or :desc' }
+      validates :carry_over_entries_to_today, inclusion: { in: [true, false], message: 'must be true or false' }
+      validates :include_all, inclusion: { in: [true, false], message: 'must be true or false' }
+      validates :theme_name, presence: true
+      validate :validate_theme_file
+      validates :default_project, presence: true
+      validate :validate_default_project
+
+      attr_accessor :version,
+        :editor,
+        :entries_display_order,
+        :carry_over_entries_to_today,
+        :include_all,
+        :theme_name,
+        :default_project
+
+      attr_reader :options
+
+      alias exist? file_exist?
+
+      def initialize(options: {})
+        super(config_path)
+
+        FileUtils.mkdir_p config_folder
+
+        @options = options || {}
+        reload
+
+        write! unless exist?
+      end
+
+      class << self
+        def exist?
+          File.exist?(Support::Fileable.config_path)
+        end
+      end
+
+      # Temporarily sets the configuration to the given config_hash.
+      # To reset the configuration to its original state, call #reload
+      def replace!(config_hash: {})
+        raise ArgumentError, 'config_hash is nil.' if config_hash.nil?
+        raise ArgumentError, "config_hash must be a Hash: \"#{config_hash}\"." unless config_hash.is_a?(Hash)
+
+        assign_attributes_from config_hash.dup
+
+        self
+      end
+
+      # Restores the configuration to its original state from disk.
+      def reload
+        file_hash = if exist?
+          read do |config_hash|
+            hydrated_hash = Services::Configuration::HydratorService.new(config_hash: config_hash).call
+            config_hash.merge!(hydrated_hash)
+          end
+        else
+          DEFAULT_CONFIGURATION.dup
+        end
+
+        assign_attributes_from file_hash
+
+        self
+      end
+
+      def carry_over_entries_to_today?
+        carry_over_entries_to_today
+      end
+
+      def to_h
+        {
+          version: version,
+          editor: editor,
+          entries_display_order: entries_display_order,
+          carry_over_entries_to_today: carry_over_entries_to_today,
+          include_all: include_all,
+          theme_name: theme_name,
+          default_project: default_project
+        }
+      end
+
+      # Override == and hash so that we can compare objects based
+      # on attributes alone. This is also useful for comparing objects
+      # in an array, for example.
+      def ==(other)
+        return false unless other.is_a?(Configuration)
+
+        to_h == other.to_h
+      end
+      alias eql? ==
+
+      def hash
+        DEFAULT_CONFIGURATION.each_key.map do |key|
+          public_send(key)
+        end.hash
+      end
+
+      def merge(hash)
+        hash.transform_keys!(&:to_sym)
+        replace!(config_hash: to_h.merge(hash))
+      end
+
+      private
+
+      def assign_attributes_from(config_hash)
+        @version = config_hash.fetch(:version, VERSION)
+        @editor = config_hash.fetch(:editor, DEFAULT_CONFIGURATION[:editor])
+        @entries_display_order = config_hash.fetch(:entries_display_order,
+          DEFAULT_CONFIGURATION[:entries_display_order])
+        @carry_over_entries_to_today = config_hash.fetch(:carry_over_entries_to_today,
+          DEFAULT_CONFIGURATION[:carry_over_entries_to_today])
+        @include_all = config_hash.fetch(:include_all, DEFAULT_CONFIGURATION[:include_all])
+        @theme_name = config_hash.fetch(:theme_name, DEFAULT_CONFIGURATION[:theme_name])
+        @default_project = config_hash.fetch(:default_project, DEFAULT_CONFIGURATION[:default_project])
+      end
+
+      def validate_theme_file
+        theme_path = themes_path(theme_name: theme_name)
+        return if File.exist?(theme_path)
+
+        i18n_key = 'configuration.errors.theme_file_missing'
+        errors.add(:base, I18n.t(i18n_key, theme_path: theme_path))
+      end
+
+      def validate_default_project
+        default_project_folder = File.join(projects_folder, default_project.presence || '{{blank}}')
+        return if Dir.exist?(default_project_folder)
+
+        i18n_key = 'configuration.errors.project_path_missing'
+        errors.add(:base, I18n.t(i18n_key, project_folder: default_project_folder))
+      end
+    end
+  end
+end

data/lib/doto/models/entry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require_relative '../support/descriptable'
+require_relative '../support/presentable'
+require_relative '../validators/description_validator'
+
+module Doto
+  module Models
+    # This class represents something someone might want to share at their
+    # daily standup (TODO).
+    class Entry
+      include ActiveModel::Model
+      include Support::Descriptable
+      include Support::Presentable
+
+      MIN_DESCRIPTION_LENGTH = 2
+      MAX_DESCRIPTION_LENGTH = 256
+
+      validates_with Validators::DescriptionValidator
+
+      attr_reader :description, :options
+
+      def initialize(description:, options: {})
+        raise ArgumentError, 'description is the wrong object type' unless description.is_a?(String)
+
+        # Make sure to call the setter method so that the description is cleaned up.
+        self.description = description
+        @options = options || {}
+      end
+
+      class << self
+        def clean_description(description)
+          return if description.nil?
+
+          description.strip.gsub(/\s+/, ' ')
+        end
+      end
+
+      def description=(description)
+        @description = self.class.clean_description description
+      end
+
+      def to_h
+        { description: description }
+      end
+
+      # Override == and hash so that we can compare Entry objects based
+      # on description alone. This is useful for comparing entries in
+      # an array, for example.
+      def ==(other)
+        return false unless other.is_a?(Entry)
+
+        description == other.description
+      end
+      alias eql? ==
+
+      def hash
+        description.hash
+      end
+    end
+  end
+end

data/lib/doto/models/entry_group.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require_relative '../crud/json_file'
+require_relative '../migration/version'
+require_relative '../services/entry_group/editor_service'
+require_relative '../support/fileable'
+require_relative '../support/presentable'
+require_relative '../support/time_comparable'
+require_relative '../support/time_formatable'
+require_relative '../validators/entries_validator'
+require_relative '../validators/time_validator'
+require_relative '../validators/version_validator'
+require_relative 'entry'
+
+module Doto
+  module Models
+    # This class represents a group of entries for a given day. IOW,
+    # things someone might want to share at their daily standup (TODO).
+    class EntryGroup < Crud::JsonFile
+      include Support::Fileable
+      include Support::Presentable
+      include Support::TimeComparable
+      include Support::TimeFormatable
+
+      ENTRIES_FILE_NAME_REGEX = /\d{4}-\d{2}-\d{2}.json/
+      ENTRIES_FILE_NAME_TIME_REGEX = /\d{4}-\d{2}-\d{2}/
+      VERSION = Migration::VERSION
+
+      attr_accessor :time, :version
+      attr_reader :entries, :options
+
+      validates_with Validators::EntriesValidator
+      validates_with Validators::TimeValidator
+      validates_with Validators::VersionValidator
+
+      def initialize(time: nil, entries: nil, version: nil, options: {})
+        raise ArgumentError, 'time is the wrong object type' unless time.is_a?(Time) || time.nil?
+        raise ArgumentError, 'version is the wrong object type' unless version.is_a?(Integer) || version.nil?
+
+        FileUtils.mkdir_p(entries_folder)
+
+        @time = ensure_local_time(time)
+
+        super(entries_path(time: @time))
+
+        @version = version || VERSION
+        self.entries = entries || []
+        @options = options || {}
+      end
+
+      # Override == and hash so that we can compare Entry Group objects.
+      def ==(other)
+        return false unless other.is_a?(EntryGroup) &&
+                            version == other.version &&
+                            time_equal?(other_time: other.time)
+
+        entries == other.entries
+      end
+      alias eql? ==
+
+      def clone
+        self.class.new(time: time, entries: entries.map(&:clone), version: version)
+      end
+
+      def delete
+        self.class.delete(time: time)
+        entries.clear
+      end
+
+      def delete!
+        self.class.delete!(time: time)
+        entries.clear
+      end
+
+      def entries=(entries)
+        entries ||= []
+
+        raise ArgumentError, 'entries is the wrong object type' unless entries.is_a?(Array)
+        raise ArgumentError, 'entries contains the wrong object type' unless entries.all?(Entry)
+
+        @entries = entries.map(&:clone)
+      end
+
+      def exist?
+        self.class.exist?(time: time)
+      end
+
+      def hash
+        entries.map(&:hash).tap do |hashes|
+          hashes << version.hash
+          hashes << time_equal_compare_string_for(time: time)
+        end.hash
+      end
+
+      def time_formatted
+        formatted_time(time: time)
+      end
+
+      def time_yyyy_mm_dd
+        yyyy_mm_dd(time: time)
+      end
+
+      def to_h
+        {
+          version: version,
+          time: time.dup,
+          entries: entries.map(&:to_h)
+        }
+      end
+
+      def valid_unique_entries
+        entries&.select(&:valid?)&.uniq(&:description)
+      end
+
+      class << self
+        def all
+          entry_files.filter_map do |file_path|
+            entry_file_name = File.basename(file_path)
+            next unless entry_file_name.match?(ENTRIES_FILE_NAME_REGEX)
+
+            entry_date = File.basename(entry_file_name, '.*')
+            find time: Time.parse(entry_date)
+          end
+        end
+
+        def any?
+          entry_files.any? do |file_path|
+            entry_date = File.basename(file_path, '.*')
+            entry_date.match?(ENTRIES_FILE_NAME_TIME_REGEX)
+          end
+        end
+
+        def delete(time:)
+          superclass.delete(file_path: entries_path_for(time: time))
+        end
+
+        def delete!(time:)
+          superclass.delete!(file_path: entries_path_for(time: time))
+        end
+
+        def edit(time:, options: {})
+          # NOTE: Uncomment this line to prohibit edits on
+          # Entry Groups that do not exist (i.e. have no entries).
+          # return new(time: time) unless exists?(time: time)
+
+          find_or_initialize(time: time).tap do |entry_group|
+            Services::EntryGroup::EditorService.new(entry_group: entry_group, options: options).call
+          end
+        end
+
+        def exist?(time:)
+          superclass.file_exist?(file_path: entries_path_for(time: time))
+        end
+
+        def entry_group_times(between: nil)
+          entry_files.filter_map do |file_path|
+            entry_file_name = File.basename(file_path)
+            next unless entry_file_name.match?(ENTRIES_FILE_NAME_REGEX)
+
+            time = File.basename(entry_file_name, '.*')
+            next if between && !Time.parse(time).between?(between.min, between.max)
+
+            time
+          end
+        end
+
+        def entry_groups(between:)
+          entry_group_times(between: between).filter_map do |time|
+            Models::EntryGroup.find(time: Time.parse(time))
+          end
+        end
+
+        def find(time:)
+          file_path = entries_path_for(time: time)
+          entry_group_hash = read!(file_path: file_path)
+          Services::EntryGroup::HydratorService.new(entry_group_hash: entry_group_hash).call
+        end
+
+        def find_or_initialize(time:)
+          file_path = entries_path_for(time: time)
+          read(file_path: file_path) do |entry_group_hash|
+            Services::EntryGroup::HydratorService.new(entry_group_hash: entry_group_hash).call
+          end || new(time: time)
+        end
+
+        def write(file_data:, file_path:)
+          if file_data[:entries].empty?
+            superclass.delete(file_path: file_path)
+            return true
+          end
+
+          super
+        end
+
+        def write!(file_data:, file_path:)
+          if file_data[:entries].empty?
+            superclass.delete!(file_path: file_path)
+            return
+          end
+
+          super
+        end
+
+        private
+
+        def entries_path_for(time:)
+          Support::Fileable.entries_path(time: time)
+        end
+
+        def entry_files
+          Dir.glob("#{Support::Fileable.entries_folder}/*")
+        end
+      end
+
+      private
+
+      def ensure_local_time(time)
+        time ||= Time.now
+        time.in_time_zone
+      end
+    end
+  end
+end

data/lib/doto/models/migration_version.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../crud/json_file'
+require_relative '../services/migration_version/hydrator_service'
+require_relative '../validators/version_validator'
+
+module Doto
+  module Models
+    # This class represents a doto migration_version.
+    class MigrationVersion < Crud::JsonFile
+      include Support::Fileable
+
+      attr_reader :options
+
+      alias exist? file_exist?
+
+      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 doto install is the
+      # current migration version.
+      def current_migration?
+        version == Doto::Migration::VERSION
+      end
+
+      def to_h
+        {
+          version: version
+        }
+      end
+    end
+  end
+end