dsu 0.1.0.alpha.5 → 1.0.0

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,7 +44,7 @@ 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
 
@@ -57,116 +55,63 @@ module Dsu
         # 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))
+          load_entry_group_file_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)
+        def load_entry_group_for(time:)
+          load_entry_group_file_for(time: time)
         end
+      end
 
-        def unique?(entry:)
-
-        end
+      def valid_unique_entries
+        entries&.select(&:valid?)&.uniq(&:description)
       end
 
-      def required_fields
-        %i[time entries]
+      def clone
+        clone = super
+
+        clone.entries = clone.entries.map(&:clone)
+        clone
       end
 
-      def edit(options: {})
-        Services::EntryGroupEditorService.new(entry_group: self, options: options).call
-        self
+      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
 
       # 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?
-      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
 

data/lib/dsu/services/entry_group_editor_service.rb

@@ -4,7 +4,10 @@ require_relative '../models/entry'
 require_relative '../support/colorable'
 require_relative '../support/say'
 require_relative '../support/time_formatable'
+require_relative '../views/edited_entries/shared/errors'
+require_relative '../views/shared/messages'
 require_relative 'configuration_loader_service'
+require_relative 'stdout_redirector_service'
 
 module Dsu
   module Services
@@ -24,7 +27,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,106 +41,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
+      def process_description?(description)
+        description = Models::Entry.clean_description(description)
+        !(description.blank? || description[0] == '#')
       end
 
       def configuration

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/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/entry_group_loadable.rb

@@ -3,6 +3,7 @@
 require 'pathname'
 require_relative '../services/entry_group_reader_service'
 require_relative '../models/entry'
+require_relative '../models/entry_group'
 
 module Dsu
   module Support
@@ -12,22 +13,19 @@ module Dsu
       # returns a Hash having :time and :entries
       # where entries == an Array of Entry Hashes
       # representing the JSON Entry objects for :time.
-      def entry_group_hash_for(time:)
+      def load_entry_group_file_for(time:)
         entry_group_json = Services::EntryGroupReaderService.new(time: time).call
-        if entry_group_json.present?
-          return JSON.parse(entry_group_json, symbolize_names: true).tap do |hash|
+        hash = if entry_group_json.present?
+          JSON.parse(entry_group_json, symbolize_names: true).tap do |hash|
             hash[:time] = Time.parse(hash[:time])
           end
+        else
+          { time: time, entries: [] }
         end
 
-        {
-          time: time,
-          entries: []
-        }
+        Models::EntryGroup.new(**hydrate_entry_group_hash(hash: hash, time: time))
       end
 
-      private
-
       # Accepts an entry group hash and returns a
       # hydrated entry group hash:
       #
@@ -39,10 +37,10 @@ module Dsu
       #     ...
       #   ]
       # }
-      def hydrate_entry_group_hash(entry_group_hash:, time:)
-        time = entry_group_hash.fetch(:time, time)
+      def hydrate_entry_group_hash(hash:, time:)
+        time = hash.fetch(:time, time)
         time = Time.parse(time) unless time.is_a? Time
-        entries = entry_group_hash.fetch(:entries, [])
+        entries = hash.fetch(:entries, [])
         entries = entries.map { |entry_hash| Models::Entry.new(**entry_hash) }
 
         { time: time, entries: entries }

data/lib/dsu/validators/description_validator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Dsu
+  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)
+          record.errors.add(field, '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?(2, 256)
+
+        if description.length < 2
+          record.errors.add(:description, "is too short: \"#{record.short_description}\" (minimum is 2 characters).")
+        elsif description.length > 256
+          record.errors.add(:description, "is too long: \"#{record.short_description}\" (maximum is 256 characters).")
+        end
+      end
+    end
+  end
+end

data/lib/dsu/validators/entries_validator.rb

@@ -7,56 +7,67 @@ require_relative '../support/field_errors'
 module Dsu
   module Validators
     class EntriesValidator < ActiveModel::Validator
-      include Dsu::Support::FieldErrors
+      include Support::FieldErrors
 
       def validate(record)
-        raise 'options[:fields] is not defined.' unless options.key? :fields
-        raise 'options[:fields] is not an Array.' unless options[:fields].is_a? Array
-        raise 'options[:fields] elements are not Symbols.' unless options[:fields].all?(Symbol)
+        unless record.entries.is_a?(Array)
+          record.errors.add(:entries_entry, 'is the wrong object type. ' \
+                                      "\"Array\" was expected, but \"#{record.entries.class}\" was received.")
+        end
 
-        options[:fields].each do |field|
-          entries = record.send(field)
+        validate_entry_types record
+        validate_unique_entry record
+        validate_entries record
+      end
 
-          unless entries.is_a?(Array)
-            record.errors.add(field, 'is the wrong object type. ' \
-                                     "\"Array\" was expected, but \"#{entries.class}\" was received.")
-            next
-          end
+      private
 
-          validate_entry_types field, entries, record
-          validate_unique_entry_attr :uuid, field, entries, record
-          validate_unique_entry_attr :description, field, entries, record
+      def validate_entry_types(record)
+        record.entries.each do |entry|
+          next if entry.is_a? Dsu::Models::Entry
+
+          record.errors.add(:entries_entry, 'entry Array element is the wrong object type. ' \
+                                      "\"Entry\" was expected, but \"#{entry.class}\" was received.",
+            type: Support::FieldErrors::FIELD_TYPE_ERROR)
         end
       end
 
-      private
+      def validate_unique_entry(record)
+        return unless record.entries.is_a? Array
 
-      def validate_entry_types(field, entries, record)
-        entries.each do |entry|
-          next if entry.is_a? Dsu::Models::Entry
+        entry_objects = record.entries.select { |entry| entry.is_a?(Dsu::Models::Entry) }
 
-          record.errors.add(field, 'entry Array element is the wrong object type. ' \
-                                   "\"Entry\" was expected, but \"#{entry.class}\" was received.",
-            type: Dsu::Support::FieldErrors::FIELD_TYPE_ERROR)
+        descriptions = entry_objects.map(&:description)
+        return if descriptions.uniq.length == descriptions.length
 
-          next
+        non_unique_descriptions = descriptions.select { |description| descriptions.count(description) > 1 }.uniq
+        if non_unique_descriptions.any?
+          record.errors.add(:entries_entry, 'contains a duplicate entry: ' \
+                                      "#{format_non_unique_descriptions(non_unique_descriptions)}.",
+            type: Support::FieldErrors::FIELD_DUPLICATE_ERROR)
         end
       end
 
-      def validate_unique_entry_attr(attr, field, entries, record)
-        return unless entries.is_a? Array
-
-        entry_objects = entries.select { |entry| entry.is_a?(Dsu::Models::Entry) }
+      def validate_entries(record)
+        entries = record.entries
+        return if entries.none?
 
-        attrs = entry_objects.map(&attr)
-        return if attrs.uniq.length == attrs.length
+        entries.each do |entry|
+          next if entry.valid?
 
-        non_unique_attrs = attrs.select { |attr| attrs.count(attr) > 1 }.uniq # rubocop:disable Lint/ShadowingOuterLocalVariable
-        if non_unique_attrs.any?
-          record.errors.add(field, "contains duplicate ##{attr}s: #{non_unique_attrs.join(', ')}.",
-            type: Dsu::Support::FieldErrors::FIELD_DUPLICATE_ERROR)
+          entry.errors.each do |error|
+            record.errors.add(:entries_entry, error.full_message)
+          end
         end
       end
+
+      def format_non_unique_descriptions(non_unique_descriptions)
+        non_unique_descriptions.map { |description| "\"#{short_description(description)}\"" }.join(', ')
+      end
+
+      def short_description(description)
+        Models::Entry.short_description(string: description)
+      end
     end
   end
 end

data/lib/dsu/validators/time_validator.rb

@@ -5,29 +5,20 @@ module Dsu
   module Validators
     class TimeValidator < ActiveModel::Validator
       def validate(record)
-        raise 'options[:fields] is not defined.' unless options.key? :fields
-        raise 'options[:fields] is not an Array.' unless options[:fields].is_a? Array
-        raise 'options[:fields] elements are not Symbols.' unless options[:fields].all?(Symbol)
+        time = record.time
 
-        options[:fields].each do |field|
-          time = record.send(field)
-
-          if time.nil?
-            record.errors.add(field, :blank)
-            next
-          end
-
-          unless time.is_a?(Time)
-            record.errors.add(field, 'is the wrong object type. ' \
-                                     "\"Time\" was expected, but \"#{time.class}\" was received.")
-            next
-          end
+        if time.nil?
+          record.errors.add(:time, :blank)
+          return
+        end
 
-          if time.utc?
-            record.errors.add(field, 'is not in localtime format.')
-            next
-          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.') if time.utc?
       end
     end
   end

data/lib/dsu/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dsu
-  VERSION = '0.1.0.alpha.5'
+  VERSION = '1.0.0'
 end