dsu 0.1.0.alpha.5 → 1.1.0.alpha.1

data/lib/dsu/models/entry_group.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'deco_lite'
+require 'active_model'
 require_relative '../services/entry_group_editor_service'
 require_relative '../services/entry_group_deleter_service'
 require_relative '../services/entry_group_reader_service'
@@ -13,30 +13,28 @@ require_relative 'entry'
 
 module Dsu
   module Models
-    class EntryGroup < DecoLite::Model
+    # 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
+      include ActiveModel::Model
       extend Support::EntryGroupLoadable
       include Support::TimeFormatable
 
-      validates_with Validators::EntriesValidator, fields: [:entries]
-      validates_with Validators::TimeValidator, fields: [:time]
+      attr_accessor :time
+      attr_reader :entries
+
+      validates_with Validators::EntriesValidator
+      validates_with Validators::TimeValidator
 
       def initialize(time: nil, entries: [])
         raise ArgumentError, 'time is the wrong object type' unless time.is_a?(Time) || time.nil?
-        raise ArgumentError, 'entries is the wrong object type' unless entries.is_a?(Array) || entries.nil?
-
-        time ||= Time.now
-        time = time.localtime if time.utc?
 
-        entries ||= []
-
-        super(hash: {
-          time: time,
-          entries: entries
-        })
+        @time = ensure_local_time(time)
+        self.entries = entries || []
       end
 
       class << self
-        def delete(time:, options: {})
+        def delete!(time:, options: {})
           Services::EntryGroupDeleterService.new(time: time, options: options).call
         end
 
@@ -46,127 +44,65 @@ module Dsu
           # return new(time: time) unless exists?(time: time)
 
           load(time: time).tap do |entry_group|
-            entry_group.edit(options: options)
+            Services::EntryGroupEditorService.new(entry_group: entry_group, options: options).call
           end
         end
 
         def exists?(time:)
           Dsu::Services::EntryGroupReaderService.entry_group_file_exists?(time: time)
         end
+      end
 
-        # Loads the EntryGroup from the file system and returns an
-        # instantiated EntryGroup object.
-        def load(time: nil)
-          new(**hydrated_entry_group_hash_for(time: time))
-        end
-
-        # This function returns a hash whose :time and :entries
-        # key values are hydrated with instantiated Time and Entry
-        # objects.
-        def hydrated_entry_group_hash_for(time:)
-          entry_group_hash = entry_group_hash_for(time: time)
-          hydrate_entry_group_hash(entry_group_hash: entry_group_hash, time: time)
-        end
+      def valid_unique_entries
+        entries&.select(&:valid?)&.uniq(&:description)
+      end
 
-        def unique?(entry:)
+      def clone
+        clone = super
 
-        end
+        clone.entries = clone.entries.map(&:clone)
+        clone
       end
 
-      def required_fields
-        %i[time entries]
-      end
+      def entries=(entries)
+        entries ||= []
 
-      def edit(options: {})
-        Services::EntryGroupEditorService.new(entry_group: self, options: options).call
-        self
+        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
 
       # Deletes the entry group file from the file system.
-      def delete
-        self.class.delete(time: time)
+      def delete!
+        self.class.delete!(time: time)
+        self.entries = []
         self
       end
 
-      def entries?
-        entries.any?
+      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
       end
 
       def to_h
-        super.tap do |hash|
-          hash[:entries] = hash[:entries].dup
-          hash[:entries].each_with_index do |entry, index|
-            hash[:entries][index] = entry.to_h
-          end
-        end
-      end
-
-      def check_unique(sha_or_editor_command:, description:)
-        raise ArgumentError, 'sha_or_editor_command is nil' if sha_or_editor_command.nil?
-        raise ArgumentError, 'description is nil' if description.nil?
-        raise ArgumentError, 'sha_or_editor_command is the wrong object type' unless sha_or_editor_command.is_a?(String)
-        raise ArgumentError, 'description is the wrong object type' unless description.is_a?(String)
-
-        if entries.blank?
-          entry_unique_hash = entry_unique_hash_for(uuid_unique: true, description_unique: true)
-          return entry_unique_struct_from(entry_unique_hash: entry_unique_hash)
-        end
-
-        entry_hash = entries.each_with_object({}) do |entry_group_entry, hash|
-          hash[entry_group_entry.uuid] = entry_group_entry.description
-        end
-
-        # It is possible that sha_or_editor_command may have an editor command (e.g. +|a|add). If this
-        # is the case, just treat it as unique because when the entry is added, it will get a unique uuid.
-        uuid_unique = !sha_or_editor_command.match?(Entry::ENTRY_UUID_REGEX) || !entry_hash.key?(sha_or_editor_command)
-        entry_unique_hash = entry_unique_hash_for(
-          uuid: sha_or_editor_command,
-          uuid_unique: uuid_unique,
-          description: description,
-          description_unique: !entry_hash.value?(description)
-        )
-        entry_unique_struct_from(entry_unique_hash: entry_unique_hash)
-      end
-
-      def entry_unique_hash_for(uuid_unique:, description_unique:, uuid: nil, description: nil)
         {
-          uuid: uuid,
-          uuid_unique: uuid_unique,
-          description: description,
-          description_unique: description_unique,
-          formatted_time: Support::TimeFormatable.formatted_time(time: time)
+          time: time.dup,
+          entries: entries.map(&:to_h)
         }
       end
 
-      def entry_unique_struct_from(entry_unique_hash:)
-        Struct.new(*entry_unique_hash.keys, keyword_init: true) do
-          def unique?
-            uuid_unique? && description_unique?
-          end
-
-          def uuid_unique?
-            uuid_unique
-          end
-
-          def description_unique?
-            description_unique
-          end
-
-          def messages
-            return [] if unique?
+      private
 
-            short_description = Models::Entry.short_description(string: description)
-
-            messages = []
-            messages << "#uuid is not unique: \"#{uuid} #{short_description}\"" unless uuid_unique?
-            messages << "#description is not unique: \"#{uuid} #{short_description}\""
-          end
-        end.new(**entry_unique_hash)
+      def ensure_local_time(time)
+        time.nil? ? Time.now : time.dup.localtime
       end
     end
   end

data/lib/dsu/services/configuration_loader_service.rb

@@ -6,6 +6,7 @@ require_relative '../support/configuration'
 
 module Dsu
   module Services
+    # This class loads an entry group file.
     class ConfigurationLoaderService
       include Dsu::Support::Configuration
 
@@ -29,9 +30,25 @@ module Dsu
       attr_reader :default_options
 
       def config_options
-        return Support::Configuration::DEFAULT_DSU_OPTIONS unless config_file?
+        return default_config unless config_file?
 
-        @config_options ||= YAML.safe_load(ERB.new(File.read(config_file)).result)
+        @config_options ||= begin
+          loaded_config = YAML.safe_load(ERB.new(File.read(config_file)).result)
+          loaded_config = update_and_write_config_file!(loaded_config) unless loaded_config.keys == default_config.keys
+          loaded_config
+        end
+      end
+
+      def update_and_write_config_file!(loaded_config)
+        loaded_config = default_config.merge(loaded_config)
+        # TODO: Make this into a configuration writer service.
+        # TODO: Test this
+        File.write(config_file, loaded_config.to_yaml)
+        loaded_config
+      end
+
+      def default_config
+        Support::Configuration::DEFAULT_DSU_OPTIONS
       end
     end
   end

data/lib/dsu/services/entry_group_editor_service.rb

@@ -2,14 +2,18 @@
 
 require_relative '../models/entry'
 require_relative '../support/colorable'
+require_relative '../support/configurable'
 require_relative '../support/say'
 require_relative '../support/time_formatable'
-require_relative 'configuration_loader_service'
+require_relative '../views/edited_entries/shared/errors'
+require_relative '../views/shared/messages'
+require_relative 'stdout_redirector_service'
 
 module Dsu
   module Services
     class EntryGroupEditorService
       include Support::Colorable
+      include Support::Configurable
       include Support::Say
       include Support::TimeFormatable
 
@@ -24,7 +28,7 @@ module Dsu
 
       def call
         edit_view = render_edit_view
-        edit!(edit_view: edit_view)
+        edit edit_view
         # NOTE: Return the original entry group object as any permanent changes
         # will have been applied to it.
         entry_group
@@ -38,110 +42,54 @@ module Dsu
       # and edit it. The edits will be used to update the entry group.
       def render_edit_view
         say "Editing entry group #{formatted_time(time: entry_group.time)}...", HIGHLIGHT
-        capture_stdxxx { Views::EntryGroup::Edit.new(entry_group: entry_group).render }
+        StdoutRedirectorService.call { Views::EntryGroup::Edit.new(entry_group: entry_group).render }
       end
 
-      # Writes the temporary file contents to disk and opens it in the editor.
-      def edit!(edit_view:)
+      # Writes the temporary file contents to disk and opens it in the editor
+      # for editing. It then copies the changes to the entry group and writes
+      # the changes to the entry group file.
+      def edit(edit_view)
+        entry_group_with_edits = Models::EntryGroup.new(time: entry_group.time)
+
         Services::TempFileWriterService.new(tmp_file_content: edit_view).call do |tmp_file_path|
-          unless Kernel.system("${EDITOR:-#{configuration[:editor]}} #{tmp_file_path}")
-            say "Failed to open temporary file in editor '#{configuration[:editor]}';" \
+          if Kernel.system("${EDITOR:-#{configuration[:editor]}} #{tmp_file_path}")
+            Services::TempFileReaderService.new(tmp_file_path: tmp_file_path).call do |editor_line|
+              next unless process_description?(editor_line)
+
+              entry_group_with_edits.entries << Models::Entry.new(description: editor_line)
+            end
+
+            process_entry_group!(entry_group_with_edits)
+          else
+            say "Failed to open temporary file in editor '#{configuration[:editor]}'; " \
                 "the system error returned was: '#{$CHILD_STATUS}'.", ERROR
             say 'Either set the EDITOR environment variable ' \
                 'or set the dsu editor configuration option (`$ dsu config init`).', ERROR
-            say 'Run `$ dsu help config` for more information.', ERROR
-
-            system('dsu help config')
-
-            return # rubocop:disable Lint/NonLocalExitFromIterator: This is not an iterator.
+            say 'Run `$ dsu help config` for more information:', ERROR
           end
-
-          update_entry_group!(tmp_file_path: tmp_file_path)
         end
       end
 
-      # TODO: Clean this up
-      def update_entry_group!(tmp_file_path:)
-        errors = []
-        entry_group.entries = entries = []
-        Services::TempFileReaderService.new(tmp_file_path: tmp_file_path).call do |tmp_file_line|
-          next if comment_or_empty?(tmp_file_line: tmp_file_line)
-
-          entry_info = editor_entry_info_from(tmp_file_line: tmp_file_line)
-          next if entry_info.empty?
-          next if delete_entry_cmd?(sha: entry_info[:sha])
-          next unless add_entry_cmd?(sha: entry_info[:sha]) || sha?(sha: entry_info[:sha])
-
-          entry_info[:sha_or_editor_command] = entry_info[:sha]
-          entry_info[:sha] = nil if add_entry_cmd?(sha: entry_info[:sha])
-
-          entry = Models::Entry.new(uuid: entry_info[:sha], description: entry_info[:description])
-          entry_group.check_unique(sha_or_editor_command: entry_info[:sha_or_editor_command],
-            description: entry_info[:description]).tap do |status|
-            entries << entry and next if status.unique?
-
-            errors << status.messages
-          end
+      def process_entry_group!(entry_group_with_edits)
+        if entry_group_with_edits.entries.empty?
+          entry_group.delete!
+          return
         end
 
-        # Display any errors encountered.
-        if errors.any?
-          say 'Error: one or more entry values were not unique within the entry group entries:', ERROR
-          errors.flatten.each { |message| say "Error: #{message}", ERROR }
+        if entry_group_with_edits.invalid?
+          header = 'The following ERRORS were encountered; these changes were not saved:'
+          messages = entry_group_with_edits.errors.full_messages
+          Views::Shared::Messages.new(messages: messages, message_type: :error, options: { header: header }).render
         end
 
-        # Save or delete any entries.
-        entry_group.entries = entries
-        entry_group.delete and return unless entry_group.entries?
-
+        # Make sure we're saving only valid, unique entries.
+        entry_group.entries = entry_group_with_edits.valid_unique_entries
         entry_group.save!
       end
 
-      def sha?(sha:)
-        sha.match?(Models::Entry::ENTRY_UUID_REGEX)
-      end
-
-      def delete_entry_cmd?(sha:)
-        %w[- d delete].include?(sha)
-      end
-
-      def add_entry_cmd?(sha:)
-        %w[+ a add].include?(sha)
-      end
-
-      def comment_or_empty?(tmp_file_line:)
-        ['#', nil].include? tmp_file_line[0]
-      end
-
-      def editor_entry_info_from(tmp_file_line:)
-        match_data = tmp_file_line.match(/(\S+)\s(.+)/)
-        {
-          sha: match_data[1]&.strip,
-          description: match_data[2]&.strip
-        }
-      rescue StandardError
-        {}
-      end
-
-      # TODO: Add this to a module.
-      # https://stackoverflow.com/questions/4459330/how-do-i-temporarily-redirect-stderr-in-ruby/4459463#4459463
-      def capture_stdxxx
-        # The output stream must be an IO-like object. In this case we capture it in
-        # an in-memory IO object so we can return the string value. You can assign any
-        # IO object here.
-        string_io = StringIO.new
-        prev_stdout, $stdout = $stdout, string_io # rubocop:disable Style/ParallelAssignment
-        prev_stderr, $stderr = $stderr, string_io # rubocop:disable Style/ParallelAssignment
-        yield
-        string_io.string
-      ensure
-        # Restore the previous value of stderr and stdout (typically equal to STDERR).
-        $stdout = prev_stdout
-        $stderr = prev_stderr
-      end
-
-      def configuration
-        @configuration ||= ConfigurationLoaderService.new.call
+      def process_description?(description)
+        description = Models::Entry.clean_description(description)
+        !(description.blank? || description[0] == '#')
       end
     end
   end

data/lib/dsu/services/stdout_redirector_service.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Services
+    # This service captures $stdout, resirects it to a StringIO object,
+    # and returns the string value.
+    # https://stackoverflow.com/questions/4459330/how-do-i-temporarily-redirect-stderr-in-ruby/4459463#4459463
+    module StdoutRedirectorService
+      class << self
+        def call
+          raise ArgumentError, 'no block was provided' unless block_given?
+
+          # The output stream must be an IO-like object. In this case we capture it in
+          # an in-memory IO object so we can return the string value. Any IO object can
+          # be used here.
+          string_io = StringIO.new
+          original_stdout, $stdout = $stdout, string_io # rubocop:disable Style/ParallelAssignment
+          yield
+          string_io.string
+        ensure
+          # Restore the original $stdout.
+          $stdout = original_stdout
+        end
+      end
+    end
+  end
+end

data/lib/dsu/subcommands/list.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
 require_relative '../base_cli'
+require_relative '../support/command_options/dsu_times'
+require_relative '../support/time_formatable'
 
 module Dsu
   module Subcommands
     class List < Dsu::BaseCLI
+      include Support::CommandOptions::DsuTimes
+      include Support::TimeFormatable
+
       map %w[d] => :date
+      map %w[dd] => :dates
       map %w[n] => :today
       map %w[t] => :tomorrow
       map %w[y] => :yesterday
@@ -17,10 +23,8 @@ module Dsu
       LONG_DESC
       def today
         time = Time.now
-        sorted_dsu_times_for(times: [time, time.yesterday]).each do |t|
-          view_entry_group(time: t)
-          puts
-        end
+        times = sorted_dsu_times_for(times: [time, time.yesterday])
+        view_list_for(times: times)
       end
 
       desc 'tomorrow, t',
@@ -30,10 +34,8 @@ module Dsu
       LONG_DESC
       def tomorrow
         time = Time.now
-        sorted_dsu_times_for(times: [time.tomorrow, time]).each do |t|
-          view_entry_group(time: t)
-          puts
-        end
+        times = sorted_dsu_times_for(times: [time.tomorrow, time])
+        view_list_for(times: times)
       end
 
       desc 'yesterday, y',
@@ -43,10 +45,8 @@ module Dsu
       LONG_DESC
       def yesterday
         time = Time.now
-        sorted_dsu_times_for(times: [time.yesterday, time.yesterday.yesterday]).each do |t|
-          view_entry_group(time: t)
-          puts
-        end
+        times = sorted_dsu_times_for(times: [time.yesterday, time.yesterday.yesterday])
+        view_list_for(times: times)
       end
 
       desc 'date, d DATE',
@@ -57,14 +57,82 @@ module Dsu
       LONG_DESC
       def date(date)
         time = Time.parse(date)
-        sorted_dsu_times_for(times: [time, time.yesterday]).each do |t|
-          view_entry_group(time: t)
-          puts
+        times = sorted_dsu_times_for(times: [time, time.yesterday])
+        view_list_for(times: times)
+      rescue ArgumentError => e
+        say "Error: #{e.message}", ERROR
+        exit 1
+      end
+
+      desc 'dates, dd OPTIONS',
+        'Displays the DSU entries for the OPTIONS provided'
+      long_desc <<~LONG_DESC
+        NAME
+        \x5
+        `dsu dates|dd OPTIONS` -- will display the DSU entries for the OPTIONS provided.
+
+        SYNOPSIS
+        \x5
+        `dsu dates|dd OPTIONS`
+
+        OPTIONS:
+        \x5
+        -f|--from DATE|MNEMONIC: ?.
+
+        \x5
+        -t|--to DATE|MNEMONIC: ?.
+
+        \x5
+        #{date_option_description}
+
+        \x5
+        #{mneumonic_option_description}
+      LONG_DESC
+      # -f, --from FROM [DATE|MNEMONIC] (e.g. -f, --from 1/1[/yyy]|n|t|y|today|tomorrow|yesterday)
+      option :from, type: :string, aliases: '-f', banner: 'DATE|MNEMONIC'
+      # -t, --to TO [DATE|MNEMONIC] (e.g. -t, --to 1/1[/yyy]|n|t|y|today|tomorrow|yesterday)
+      option :to, type: :string, aliases: '-t', banner: 'DATE|MNEMONIC'
+
+      # Include dates that have no DSU entries.
+      option :include_all, type: :boolean, aliases: '-a'
+      def dates
+        options = configuration.merge(self.options)
+        times = dsu_times_from!(from_command_option: options[:from], to_command_option: options[:to])
+        # Note special sort here, unlike the other commands where rules for
+        # displaying DSU entries are applied; this is more of a list command.
+        times = times_sort(times: times, entries_display_order: entries_display_order)
+        view_entry_groups(times: times, options: options) do |total_entry_groups|
+          nothing_to_display_banner_for(times) if total_entry_groups.zero?
         end
       rescue ArgumentError => e
         say "Error: #{e.message}", ERROR
         exit 1
       end
+
+      private
+
+      def nothing_to_display_banner_for(entry_group_times)
+        entry_group_times.sort!
+        time_range = "#{formatted_time(time: entry_group_times.first)} " \
+                     "through #{formatted_time(time: entry_group_times.last)}"
+        say "(nothing to display for #{time_range})", INFO
+      end
+
+      # This method will unconditionally display the FIRST and LAST entry groups
+      # associated with the times provided by the <times> argument. All other
+      # entry groups will be conditionally displayed based on the :include_all
+      # value in the <options> argument.
+      def view_list_for(times:)
+        options = configuration.merge(self.options)
+        times_first_and_last = [times.first, times.last]
+        times.each do |time|
+          view_options = options.dup
+          view_options[:include_all] = true if times_first_and_last.include?(time)
+          view_entry_group(time: time, options: view_options) do
+            puts
+          end
+        end
+      end
     end
   end
 end

data/lib/dsu/support/colorable.rb

@@ -6,6 +6,7 @@ module Dsu
       ABORTED = :red
       ERROR = :red
       HIGHLIGHT = :cyan
+      INFO = HIGHLIGHT
       SUCCESS = :green
       WARNING = :yellow
     end

data/lib/dsu/support/command_options/dsu_times.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'time'
+require_relative 'time_mneumonic'
+require_relative 'time_mneumonics'
+
+module Dsu
+  module Support
+    module CommandOptions
+      module DsuTimes
+        include Time
+        include TimeMneumonic
+        include TimeMneumonics
+
+        # Returns an array of Time objects. The first element is the from time. The second element is the to time.
+        # Both arguments are expected to be command options that are time strings, time or relative time mneumonics.
+        def dsu_times_from!(from_command_option:, to_command_option:)
+          times = begin
+            from_time = time_from_mneumonic(command_option: from_command_option) if time_mneumonic?(from_command_option)
+            from_time ||= time_from_date_string(command_option: from_command_option)
+
+            to_time = time_from_mneumonic(command_option: to_command_option) if time_mneumonic?(to_command_option)
+            to_time ||= time_from_date_string(command_option: to_command_option)
+
+            [from_time, to_time].sort
+          end
+
+          (times.min.to_date..times.max.to_date).map(&:to_time)
+        end
+      end
+    end
+  end
+end