dsu 0.1.0.alpha.4 → 1.0.0

data/lib/dsu/services/configuration_loader_service.rb

@@ -6,11 +6,10 @@ require_relative '../support/configuration'
 
 module Dsu
   module Services
+    # This class loads an entry group file.
     class ConfigurationLoaderService
       include Dsu::Support::Configuration
 
-      attr_reader :default_options
-
       def initialize(default_options: nil)
         unless default_options.nil? ||
                default_options.is_a?(Hash) ||
@@ -18,7 +17,7 @@ module Dsu
           raise ArgumentError, 'default_options must be a Hash or ActiveSupport::HashWithIndifferentAccess'
         end
 
-        @default_options ||= default_options || {}
+        @default_options = default_options || {}
         @default_options = @default_options.with_indifferent_access if @default_options.is_a?(Hash)
       end
 
@@ -28,6 +27,8 @@ module Dsu
 
       private
 
+      attr_reader :default_options
+
       def config_options
         return Support::Configuration::DEFAULT_DSU_OPTIONS unless config_file?
 

data/lib/dsu/services/entry_group_editor_service.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+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
+    class EntryGroupEditorService
+      include Support::Colorable
+      include Support::Say
+      include Support::TimeFormatable
+
+      def initialize(entry_group:, options: {})
+        raise ArgumentError, 'entry_group is nil' if entry_group.nil?
+        raise ArgumentError, 'entry_group is the wrong object type' unless entry_group.is_a?(Models::EntryGroup)
+        raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash) || options.nil?
+
+        @entry_group = entry_group
+        @options = options || {}
+      end
+
+      def call
+        edit_view = render_edit_view
+        edit edit_view
+        # NOTE: Return the original entry group object as any permanent changes
+        # will have been applied to it.
+        entry_group
+      end
+
+      private
+
+      attr_reader :entry_group, :options
+
+      # Renders the edit view to a string so we can write it to a temporary file
+      # 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
+        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
+      # 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|
+          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
+          end
+        end
+      end
+
+      def process_entry_group!(entry_group_with_edits)
+        if entry_group_with_edits.entries.empty?
+          entry_group.delete!
+          return
+        end
+
+        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
+
+        # Make sure we're saving only valid, unique entries.
+        entry_group.entries = entry_group_with_edits.valid_unique_entries
+        entry_group.save!
+      end
+
+      def process_description?(description)
+        description = Models::Entry.clean_description(description)
+        !(description.blank? || description[0] == '#')
+      end
+
+      def configuration
+        @configuration ||= ConfigurationLoaderService.new.call
+      end
+    end
+  end
+end

data/lib/dsu/services/entry_group_writer_service.rb

@@ -26,6 +26,7 @@ module Dsu
         entry_group.validate!
         create_entry_group_path_if!
         write_entry_group_to_file!
+        entry_group
       rescue ActiveModel::ValidationError
         puts "Error(s) encountered: #{entry_group.errors.full_messages}"
         raise

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/services/temp_file_reader_service.rb

@@ -3,29 +3,29 @@
 module Dsu
   module Services
     class TempFileReaderService
-      def initialize(temp_file_path:, options: {})
-        raise ArgumentError, 'temp_file_path is nil' if temp_file_path.nil?
-        raise ArgumentError, 'temp_file_path is the wrong object type' unless temp_file_path.is_a?(String)
-        raise ArgumentError, 'temp_file_path is empty' if temp_file_path.empty?
-        raise ArgumentError, 'temp_file_path does not exist' unless File.exist?(temp_file_path)
+      def initialize(tmp_file_path:, options: {})
+        raise ArgumentError, 'tmp_file_path is nil' if tmp_file_path.nil?
+        raise ArgumentError, 'tmp_file_path is the wrong object type' unless tmp_file_path.is_a?(String)
+        raise ArgumentError, 'tmp_file_path is empty' if tmp_file_path.empty?
+        raise ArgumentError, 'tmp_file_path does not exist' unless File.exist?(tmp_file_path)
         raise ArgumentError, 'options is nil' if options.nil?
         raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash)
 
-        @temp_file_path = temp_file_path
+        @tmp_file_path = tmp_file_path
         @options = options || {}
       end
 
       def call
         raise ArgumentError, 'no block given' unless block_given?
 
-        File.foreach(temp_file_path) do |line|
+        File.foreach(tmp_file_path) do |line|
           yield line.strip
         end
       end
 
       private
 
-      attr_reader :temp_file_path, :options
+      attr_reader :tmp_file_path, :options
     end
   end
 end

data/lib/dsu/services/temp_file_writer_service.rb

@@ -5,13 +5,13 @@ require 'tempfile'
 module Dsu
   module Services
     class TempFileWriterService
-      def initialize(temp_file_content:, options: {})
-        raise ArgumentError, 'temp_file_content is nil' if temp_file_content.nil?
-        raise ArgumentError, 'temp_file_content is the wrong object type' unless temp_file_content.is_a?(String)
+      def initialize(tmp_file_content:, options: {})
+        raise ArgumentError, 'tmp_file_content is nil' if tmp_file_content.nil?
+        raise ArgumentError, 'tmp_file_content is the wrong object type' unless tmp_file_content.is_a?(String)
         raise ArgumentError, 'options is nil' if options.nil?
         raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash)
 
-        @temp_file_content = temp_file_content
+        @tmp_file_content = tmp_file_content
         @options = options || {}
       end
 
@@ -19,7 +19,7 @@ module Dsu
         raise ArgumentError, 'no block given' unless block_given?
 
         Tempfile.new('dsu').tap do |file|
-          file.write("#{temp_file_content}\n")
+          file.write("#{tmp_file_content}\n")
           file.close
           yield file.path
         end.unlink
@@ -27,7 +27,7 @@ module Dsu
 
       private
 
-      attr_reader :temp_file_content, :options
+      attr_reader :tmp_file_content, :options
     end
   end
 end

data/lib/dsu/subcommands/edit.rb

@@ -1,19 +1,12 @@
 # frozen_string_literal: true
 
-require 'English'
 require_relative '../base_cli'
 require_relative '../models/entry_group'
-require_relative '../services/temp_file_reader_service'
-require_relative '../services/temp_file_writer_service'
-require_relative '../support/time_formatable'
-require_relative '../views/entry_group/edit'
 require_relative '../views/entry_group/show'
 
 module Dsu
   module Subcommands
     class Edit < Dsu::BaseCLI
-      include Support::TimeFormatable
-
       map %w[d] => :date
       map %w[n] => :today
       map %w[t] => :tomorrow
@@ -25,7 +18,8 @@ module Dsu
        Edits the DSU entries for today.
       LONG_DESC
       def today
-        Views::EntryGroup::Show.new(entry_group: edit_entry_group(time: Time.now)).render
+        entry_group = Models::EntryGroup.edit(time: Time.now)
+        Views::EntryGroup::Show.new(entry_group: entry_group).render
       end
 
       desc 'tomorrow, t',
@@ -34,7 +28,8 @@ module Dsu
         Edits the DSU entries for tomorrow.
       LONG_DESC
       def tomorrow
-        Views::EntryGroup::Show.new(entry_group: edit_entry_group(time: Time.now.tomorrow)).render
+        entry_group = Models::EntryGroup.edit(time: Time.now.tomorrow)
+        Views::EntryGroup::Show.new(entry_group: entry_group).render
       end
 
       desc 'yesterday, y',
@@ -43,7 +38,8 @@ module Dsu
         Edits the DSU entries for yesterday.
       LONG_DESC
       def yesterday
-        Views::EntryGroup::Show.new(entry_group: edit_entry_group(time: Time.now.yesterday)).render
+        entry_group = Models::EntryGroup.edit(time: Time.now.yesterday)
+        Views::EntryGroup::Show.new(entry_group: entry_group).render
       end
 
       desc 'date, d DATE',
@@ -54,79 +50,12 @@ module Dsu
         \x5 #{date_option_description}
       LONG_DESC
       def date(date)
-        Views::EntryGroup::Show.new(entry_group: edit_entry_group(time: Time.parse(date))).render
+        entry_group = Models::EntryGroup.edit(time: Time.parse(date))
+        Views::EntryGroup::Show.new(entry_group: entry_group).render
       rescue ArgumentError => e
         say "Error: #{e.message}", ERROR
         exit 1
       end
-
-      private
-
-      def edit_entry_group(time:)
-        formatted_time = formatted_time(time: time)
-        unless Models::EntryGroup.exists?(time: time)
-          say "No DSU entries exist for #{formatted_time}"
-          exit 1
-        end
-
-        say "Editing DSU entries for #{formatted_time}..."
-        entry_group = Models::EntryGroup.load(time: time)
-
-        # This renders the view to a string...
-        output = capture_stdxxx do
-          Views::EntryGroup::Edit.new(entry_group: entry_group).render
-        end
-        # ...which is then written to a temp file.
-        Services::TempFileWriterService.new(temp_file_content: output).call do |temp_file_path|
-          unless system("${EDITOR:-#{configuration[:editor]}} #{temp_file_path}")
-            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')
-            exit 1
-          end
-          entries = []
-          Services::TempFileReaderService.new(temp_file_path: temp_file_path).call do |temp_file_line|
-            # Skip comments and blank lines.
-            next if ['#', nil].include? temp_file_line[0]
-
-            match_data = temp_file_line.match(/(\S+)\s(.+)/)
-            # TODO: Error handling if match_data is nil.
-            entry_sha = match_data[1]
-            entry_description = match_data[2]
-
-            next if %w[- d delete].include?(entry_sha) # delete the entry
-
-            entry_sha = nil if %w[+ a add].include?(entry_sha) # add the new entry
-            entries << Models::Entry.new(uuid: entry_sha, description: entry_description)
-          end
-
-          entry_group.entries = entries
-
-          return entry_group.delete if entries.empty?
-
-          entry_group.save!
-        end
-        entry_group
-      end
-
-      # 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
     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/descriptable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module Descriptable
+      class << self
+        def included(mod)
+          mod.extend(ClassMethods)
+        end
+      end
+
+      def short_description
+        return '' if description.blank?
+
+        self.class.short_description(string: description)
+      end
+
+      module ClassMethods
+        def short_description(string:, count: 25, elipsis: '...')
+          return elipsis unless string.is_a?(String)
+
+          elipsis_length = elipsis.length
+          count = elipsis_length if count.nil? || count < elipsis_length
+
+          return string if string.length <= count
+
+          tokens = string.split
+          string = ''
+
+          return "#{tokens.first[0..(count - elipsis_length)]}#{elipsis}" if tokens.count == 1
+
+          tokens.each do |token|
+            break if string.length + token.length + elipsis_length > count
+
+            string = "#{string} #{token}"
+          end
+
+          "#{string.strip}#{elipsis}"
+        end
+      end
+    end
+  end
+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,55 +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_uuids 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_uuids(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?
 
-        uuids = entry_objects.map(&:uuid)
-        return if uuids.uniq.length == uuids.length
+        entries.each do |entry|
+          next if entry.valid?
 
-        non_unique_uuids = uuids.select { |element| uuids.count(element) > 1 }.uniq
-        if non_unique_uuids.any?
-          record.errors.add(field, "contains duplicate UUIDs: #{non_unique_uuids.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.4'
+  VERSION = '1.0.0'
 end