dsu 1.2.1 → 2.0.1

data/lib/dsu/models/color_theme.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../crud/json_file'
+require_relative '../migration/version'
+require_relative '../support/color_themable'
+require_relative '../support/descriptable'
+require_relative '../support/fileable'
+require_relative '../support/presentable'
+require_relative '../validators/color_theme_validator'
+require_relative '../validators/description_validator'
+require_relative '../validators/version_validator'
+require_relative 'configuration'
+
+module Dsu
+  module Models
+    # This class represents a dsu color theme.
+    class ColorTheme < Crud::JsonFile
+      include Support::ColorThemable
+      include Support::Descriptable
+      include Support::Fileable
+      include Support::Presentable
+
+      VERSION = Migration::VERSION
+
+      DEFAULT_THEME_NAME = 'default'
+      # Theme colors key/value pair format:
+      # <key>: { color: <color> [, mode: <mode>] [, background: <background>] }
+      # Where <color> (required) == any color represented in the colorize gem `String.colors` array.
+      #       <mode> (optional, default is :default) == any mode represented in the colorize gem `String.modes` array.
+      #       <background> (optional, default is :default) == any color represented in the colorize gem
+      #                    `String.colors` array.
+      DEFAULT_THEME_COLORS = {
+        help: { color: :cyan },
+        dsu_header: { color: :white, mode: :bold, background: :cyan },
+        dsu_footer: { color: :cyan },
+        header: { color: :cyan, mode: :bold },
+        subheader: { color: :cyan, mode: :underline },
+        body: { color: :cyan },
+        footer: { color: :light_cyan },
+        date: { color: :cyan, mode: :bold },
+        index: { color: :light_cyan },
+        # Status colors.
+        info: { color: :cyan },
+        success: { color: :green },
+        warning: { color: :yellow },
+        error: { color: :light_yellow, background: :red },
+        # Prompts
+        prompt: { color: :cyan, mode: :bold },
+        prompt_options: { color: :white, mode: :bold }
+      }.freeze
+      DEFAULT_THEME = {
+        version: VERSION,
+        description: 'Default theme.'
+      }.merge(DEFAULT_THEME_COLORS).freeze
+
+      # TODO: Validate other attrs.
+      validates_with Validators::DescriptionValidator
+      validates_with Validators::ColorThemeValidator
+      validates_with Validators::VersionValidator
+
+      attr_reader :theme_name, :options
+
+      def initialize(theme_name:, theme_hash: nil, options: {})
+        raise ArgumentError, 'theme_name is nil.' if theme_name.nil?
+        raise ArgumentError, "theme_name is the wrong object type: \"#{theme_name}\"." unless theme_name.is_a?(String)
+        unless theme_hash.is_a?(Hash) || theme_hash.nil?
+          raise ArgumentError, "theme_hash is the wrong object type: \"#{theme_hash}\"."
+        end
+
+        FileUtils.mkdir_p themes_folder
+
+        @theme_name = theme_name
+        @options = options || {}
+
+        super(self.class.send(:themes_path_for, theme_name: @theme_name))
+
+        theme_hash ||= DEFAULT_THEME.merge(description: "#{@theme_name.capitalize} theme")
+
+        # Color themes I expect will change a lot, so we're using
+        # a little meta-programming here to dynamically create
+        # public attr_readers and private attr_writers based on the
+        # keys in DEFAULT_THEME, then assign those attributes from
+        # the values in theme_hash. theme_hash will be guaranteed to
+        # have the same keys as DEFAULT_THEME.keys at this point
+        # because we called ensure_theme_hash! above.
+        DEFAULT_THEME.each_key do |attr|
+          self.class.class_eval do
+            attr_reader attr
+            attr_writer attr
+            private "#{attr}="
+          end
+          attr_value = theme_hash[attr]
+          attr_value = attr_value.merge_default_colors if default_theme_color_keys.include?(attr)
+          send("#{attr}=", attr_value)
+        end
+      end
+
+      def delete
+        self.class.delete(theme_name: theme_name)
+      end
+
+      def delete!
+        self.class.delete!(theme_name: theme_name)
+      end
+
+      def exist?
+        self.class.exist?(theme_name: theme_name)
+      end
+
+      class << self
+        def all
+          Dir.glob("#{themes_folder}/*").map do |file_path|
+            theme_name = File.basename(file_path, '.*')
+            find(theme_name: theme_name)
+          end
+        end
+
+        def configuration
+          Models::Configuration.new
+        end
+
+        def current
+          theme_name = configuration.theme_name
+          return unless exist?(theme_name: theme_name)
+
+          find(theme_name: theme_name)
+        end
+
+        # Returns the current color theme if it exists; otherwise,
+        # it returns the default color theme.
+        def current_or_default
+          current || default
+        end
+
+        def default
+          new(theme_name: DEFAULT_THEME_NAME, theme_hash: DEFAULT_THEME)
+        end
+
+        def delete(theme_name:)
+          superclass.delete(file_path: themes_path_for(theme_name: theme_name))
+        end
+
+        def delete!(theme_name:)
+          superclass.delete!(file_path: themes_path_for(theme_name: theme_name))
+        end
+
+        def ensure_color_theme_color_defaults_for(theme_hash: DEFAULT_THEME)
+          theme_hash = theme_hash.dup
+
+          theme_hash.each_pair do |key, value|
+            next unless default_theme_color_keys.include?(key)
+
+            theme_hash[key] = value.merge_default_colors
+          end
+          theme_hash
+        end
+
+        def exist?(theme_name:)
+          superclass.exist?(file_path: themes_path_for(theme_name: theme_name))
+        end
+
+        def find(theme_name:)
+          theme_hash = read!(file_path: themes_path_for(theme_name: theme_name))
+          Services::ColorTheme::HydratorService.new(theme_name: theme_name, theme_hash: theme_hash).call
+        end
+
+        def find_or_create(theme_name:)
+          return find(theme_name: theme_name) if exist?(theme_name: theme_name)
+
+          new(theme_name: theme_name).tap(&:write!)
+        end
+
+        def find_or_initialize(theme_name:)
+          return find(theme_name: theme_name) if exist?(theme_name: theme_name)
+
+          new(theme_name: theme_name)
+        end
+
+        # TODO: Unused?
+        # def build_color_theme(theme_name:, base_color:, description:)
+        #   theme_hash = Models::ColorTheme.send(:replace, color_theme: default,
+        #     replace_color: :cyan, with_color: base_color).tap do |hash|
+        #     hash[:description] = description
+        #   end
+        #   new(theme_name: theme_name, theme_hash: theme_hash)
+        # end
+
+        private
+
+        def default_theme_color_keys
+          DEFAULT_THEME_COLORS.keys
+        end
+
+        def replace(color_theme:, replace_color:, with_color:)
+          colors_theme_hash = color_theme.to_theme_colors_h.tap do |hash|
+            hash.each_key do |key|
+              hash[key] = replace_color(theme_color: hash[key],
+                replace_color: replace_color, with_color: with_color)
+            end
+          end
+          DEFAULT_THEME.merge(colors_theme_hash)
+        end
+
+        def replace_color(theme_color:, replace_color:, with_color:)
+          %i[color background].each do |color_type|
+            color = theme_color[color_type].to_s.sub(replace_color.to_s, with_color.to_s)
+            theme_color[color_type] = color.sub('light_light_', 'light_').to_sym
+          end
+          theme_color
+        end
+
+        # If the color theme is deleted (deleted_theme_name) and the current
+        # theme_name in the configuration is the same as the deleted theme,
+        # we need to reset the configuration theme to the default theme.
+        def reset_default_configuration_color_theme_if!(deleted_theme_name:)
+          config = configuration
+          return if config.theme_name == self::DEFAULT_THEME_NAME
+          return unless config.theme_name == deleted_theme_name
+          return unless config.exist?
+
+          config.theme_name = self::DEFAULT_THEME_NAME
+          config.write!
+        end
+
+        def themes_path_for(theme_name:)
+          Support::Fileable.themes_path(theme_name: theme_name)
+        end
+      end
+
+      def to_h
+        {}.tap do |hash|
+          DEFAULT_THEME.each_key do |key|
+            hash[key] = public_send(key)
+          end
+        end
+      end
+
+      def to_theme_colors_h
+        {}.tap do |hash|
+          DEFAULT_THEME_COLORS.each_key do |key|
+            hash[key] = public_send(key)
+          end
+        end
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        return false unless other.theme_name == theme_name
+
+        DEFAULT_THEME.keys.all? { |key| public_send(key) == other.public_send(key) }
+      end
+      alias eql? ==
+
+      def hash
+        DEFAULT_THEME.keys.map { |key| public_send(key) }.tap do |hashes|
+          hashes << theme_name.hash
+        end.hash
+      end
+
+      private
+
+      attr_writer :theme_name, :description
+
+      def default_theme_color_keys
+        @default_theme_color_keys ||= self.class.send(:default_theme_color_keys)
+      end
+    end
+  end
+end

data/lib/dsu/models/configuration.rb

@@ -0,0 +1,160 @@
+# 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 Dsu
+  module Models
+    # This class represents the dsu 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 dsu commands that list date ranges (e.g.
+        # `dsu list dates`), the displayed list will include dates that
+        # have no dsu entries. If false, the displayed list will only
+        # include dates that have dsu entries.
+        # For all other `dsu 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 DSU date has entries or not;
+        # all other dates will not be displayed if the DSU 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'
+      }.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
+
+      attr_accessor :version,
+        :editor,
+        :entries_display_order,
+        :carry_over_entries_to_today,
+        :include_all,
+        :theme_name
+
+      attr_reader :options
+
+      def initialize(options: {})
+        super(config_path)
+
+        FileUtils.mkdir_p config_folder
+
+        @options = options || {}
+        reload
+
+        write! unless exist?
+      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
+        }
+      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)
+        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])
+      end
+
+      def validate_theme_file
+        theme_path = themes_path(theme_name: theme_name)
+        return if File.exist?(theme_path)
+
+        errors.add(:base, "Theme file \"#{theme_path}\" does not exist")
+      end
+    end
+  end
+end

data/lib/dsu/models/entry.rb

@@ -2,6 +2,7 @@
 
 require 'active_model'
 require_relative '../support/descriptable'
+require_relative '../support/presentable'
 require_relative '../validators/description_validator'
 
 module Dsu
@@ -11,15 +12,18 @@ module Dsu
     class Entry
       include ActiveModel::Model
       include Support::Descriptable
+      include Support::Presentable
 
       validates_with Validators::DescriptionValidator
 
-      attr_reader :description
+      attr_reader :description, :options
 
-      def initialize(description:)
+      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

data/lib/dsu/models/entry_group.rb

@@ -1,64 +1,76 @@
 # frozen_string_literal: true
 
 require 'active_model'
-require_relative '../services/entry_group_editor_service'
-require_relative '../services/entry_group_deleter_service'
-require_relative '../services/entry_group_reader_service'
-require_relative '../services/entry_group_writer_service'
-require_relative '../support/entry_group_loadable'
+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 Dsu
   module Models
     # This class represents a group of entries for a given day. IOW,
     # things someone might want to share at their daily standup (DSU).
-    class EntryGroup
-      extend Support::EntryGroupLoadable
-      include ActiveModel::Model
+    class EntryGroup < Crud::JsonFile
+      include Support::Fileable
+      include Support::Presentable
+      include Support::TimeComparable
       include Support::TimeFormatable
 
-      attr_accessor :time
-      attr_reader :entries
+      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: [])
+      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
 
-      class << self
-        def delete!(time:, options: {})
-          Services::EntryGroupDeleterService.new(time: time, options: options).call
-        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)
+      # 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)
 
-          load(time: time).tap do |entry_group|
-            Services::EntryGroupEditorService.new(entry_group: entry_group, options: options).call
-          end
-        end
+        entries == other.entries
+      end
+      alias eql? ==
 
-        def exists?(time:)
-          Dsu::Services::EntryGroupReaderService.entry_group_file_exists?(time: time)
-        end
+      def clone
+        self.class.new(time: time, entries: entries.map(&:clone), version: version)
       end
 
-      def valid_unique_entries
-        entries&.select(&:valid?)&.uniq(&:description)
+      def delete
+        self.class.delete(time: time)
+        entries.clear
       end
 
-      def clone
-        self.class.new(time: time, entries: entries.map(&:clone))
+      def delete!
+        self.class.delete!(time: time)
+        entries.clear
       end
 
       def entries=(entries)
@@ -70,32 +82,121 @@ module Dsu
         @entries = entries.map(&:clone)
       end
 
-      # Deletes the entry group file from the file system.
-      def delete!
-        self.class.delete!(time: time)
-        self.entries = []
-        self
+      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 save!
-        delete! and return if entries.empty?
-
-        validate!
-        Services::EntryGroupWriterService.new(entry_group: self).call
-        self
+      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, '.*')
+            file_path = entries_path_for(time: Time.parse(entry_date))
+            entry_group_hash = read!(file_path: file_path)
+            Services::EntryGroup::HydratorService.new(entry_group_hash: entry_group_hash).call
+          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.exist?(file_path: entries_path_for(time: time))
+        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_create(time:)
+          find_or_initialize(time: time).tap do |entry_group|
+            entry_group.write! unless entry_group.exist?
+          end
+        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:)
+          delete(file_path: file_path) and return true if file_data[:entries].empty?
+
+          super
+        end
+
+        def write!(file_data:, file_path:)
+          delete!(file_path: file_path) and return if file_data[:entries].empty?
+
+          super
+        end
+
+        private
+
+        def entries_path_for(time:)
+          Support::Fileable.entries_path(time: time)
+        end
+
+        def entry_files
+          Dir.glob("#{entries_folder}/*")
+        end
+      end
+
       private
 
       def ensure_local_time(time)