dsu 0.1.0.alpha.1 → 0.1.0.alpha.3

data/lib/dsu/models/entry_group.rb

@@ -2,7 +2,9 @@
 
 require 'deco_lite'
 require_relative '../support/entry_group_loadable'
+require_relative '../services/entry_group_deleter_service'
 require_relative '../services/entry_group_reader_service'
+require_relative '../services/entry_group_writer_service'
 require_relative '../validators/entries_validator'
 require_relative '../validators/time_validator'
 
@@ -30,10 +32,16 @@ module Dsu
       end
 
       class << self
+        def delete(time:, options: {})
+          Services::EntryGroupDeleterService.new(time: time, options: options).call
+        end
+
         def exists?(time:)
           Dsu::Services::EntryGroupReaderService.entry_group_file_exists?(time: time)
         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
@@ -51,6 +59,18 @@ module Dsu
         %i[time entries]
       end
 
+      def save!
+        validate!
+        Services::EntryGroupWriterService.new(entry_group: self).call
+        self
+      end
+
+      # Deletes the entry group file from the file system.
+      def delete
+        self.class.delete(time: time)
+        self
+      end
+
       def to_h
         super.tap do |hash|
           hash[:entries] = hash[:entries].dup

data/lib/dsu/services/configuration_loader_service.rb

@@ -11,23 +11,27 @@ module Dsu
 
       attr_reader :default_options
 
-      def initialize(default_options: Dsu::Support::Configuration::DEFAULT_DSU_OPTIONS)
-        @default_options = default_options
+      def initialize(default_options: nil)
+        unless default_options.nil? ||
+               default_options.is_a?(Hash) ||
+               default_options.is_a?(ActiveSupport::HashWithIndifferentAccess)
+          raise ArgumentError, 'default_options must be a Hash or ActiveSupport::HashWithIndifferentAccess'
+        end
+
+        @default_options ||= default_options || {}
+        @default_options = @default_options.with_indifferent_access if @default_options.is_a?(Hash)
       end
 
       def call
-        load_config.merge(default_options || {}).presence&.with_indifferent_access || raise('No configuration options found')
+        config_options.merge(default_options).with_indifferent_access
       end
 
       private
 
-      attr_writer :default_options
+      def config_options
+        return Support::Configuration::DEFAULT_DSU_OPTIONS unless config_file?
 
-      def load_config
-        return {} unless config_file?
-
-        yaml_options = File.read(config_file)
-        YAML.safe_load ERB.new(yaml_options).result
+        @config_options ||= YAML.safe_load(ERB.new(File.read(config_file)).result)
       end
     end
   end

data/lib/dsu/services/temp_file_reader_service.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+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)
+        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
+        @options = options || {}
+      end
+
+      def call
+        raise ArgumentError, 'no block given' unless block_given?
+
+        File.foreach(temp_file_path) do |line|
+          yield line.strip
+        end
+      end
+
+      private
+
+      attr_reader :temp_file_path, :options
+    end
+  end
+end

data/lib/dsu/services/temp_file_writer_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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)
+        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
+        @options = options || {}
+      end
+
+      def call
+        raise ArgumentError, 'no block given' unless block_given?
+
+        Tempfile.new('dsu').tap do |file|
+          file.write("#{temp_file_content}\n")
+          file.close
+          yield file.path
+        end.unlink
+      end
+
+      private
+
+      attr_reader :temp_file_content, :options
+    end
+  end
+end

data/lib/dsu/subcommands/config.rb

@@ -33,14 +33,44 @@ module Dsu
       desc 'init', 'Creates and initializes a .dsu file in your home folder'
       long_desc <<-LONG_DESC
         NAME
-        \x5
-        `dsu config init` -- will create and initialize a .dsu file
-        in the "#{Dsu::Support::FolderLocations.root_folder}" folder.
+
+        `dsu config init` -- will create and initialize a .dsu file ("#{Dsu::Support::FolderLocations.root_folder}/.dsu") that you may edit. Otherwise, the default configuration will be used.
 
         SYNOPSIS
-        \x5
+
         dsu config init
+
+        CONFIGURATION FILE OPTIONS
+
+        The following configuration file options are available:
+
+        editor:
+
+        The default editor to use when editing entry groups if the EDITOR environment variable on your system is not set. The default is 'nano'. You'll need to change the default editor on Windows systems.
+
+        entries_display_order:
+
+        The order by which entries will be displayed, 'asc' or 'desc' (ascending or descending, respectively).
+
+        Default: 'desc'
+
+        entries_file_name:
+
+        The entries file name format. It is recommended that you do not change this. The file name must include `%Y`, `%m` and `%d` `Time` formatting specifiers to make sure the file name is unique and able to be located by `dsu` functions. For example, the default file name is `%Y-%m-%d.json`; however, something like `%m-%d-%Y.json` or `entry-group-%m-%d-%Y.json` would work as well.
+
+        ATTENTION: Please keep in mind that if you change this value `dsu` will not recognize entry files using a different format. You would (at this time), have to manually rename any existing entry file names to the new format.
+
+        Default: '%Y-%m-%d.json'
+
+        entries_folder:
+
+        This is the folder where `dsu` stores entry files. You may change this to anything you want. `dsu` will create this folder for you, as long as your system's write permissions allow this.
+
+        ATTENTION: Please keep in mind that if you change this value `dsu` will not be able to find entry files in any previous folder. You would (at this time), have to manually mode any existing entry files to this new folder.
+
+        Default: "'#{Dsu::Support::FolderLocations.root_folder}/dsu/entries'"
       LONG_DESC
+
       def init
         create_config_file!
       end

data/lib/dsu/subcommands/edit.rb

@@ -0,0 +1,132 @@
+# 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
+      map %w[y] => :yesterday
+
+      desc 'today, n',
+        'Edits the DSU entries for today.'
+      long_desc <<-LONG_DESC
+       Edits the DSU entries for today.
+      LONG_DESC
+      def today
+        Views::EntryGroup::Show.new(entry_group: edit_entry_group(time: Time.now)).render
+      end
+
+      desc 'tomorrow, t',
+        'Edits the DSU entries for tomorrow.'
+      long_desc <<-LONG_DESC
+        Edits the DSU entries for tomorrow.
+      LONG_DESC
+      def tomorrow
+        Views::EntryGroup::Show.new(entry_group: edit_entry_group(time: Time.now.tomorrow)).render
+      end
+
+      desc 'yesterday, y',
+        'Edits the DSU entries for yesterday.'
+      long_desc <<-LONG_DESC
+        Edits the DSU entries for yesterday.
+      LONG_DESC
+      def yesterday
+        Views::EntryGroup::Show.new(entry_group: edit_entry_group(time: Time.now.yesterday)).render
+      end
+
+      desc 'date, d DATE',
+        'Edits the DSU entries for DATE.'
+      long_desc <<-LONG_DESC
+        Edits the DSU entries for DATE.
+
+        \x5 #{date_option_description}
+      LONG_DESC
+      def date(date)
+        Views::EntryGroup::Show.new(entry_group: edit_entry_group(time: Time.parse(date))).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/subcommands/list.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../base_cli'
+
+module Dsu
+  module Subcommands
+    class List < Dsu::BaseCLI
+      map %w[d] => :date
+      map %w[n] => :today
+      map %w[t] => :tomorrow
+      map %w[y] => :yesterday
+
+      desc 'today, n',
+        'Displays the DSU entries for today'
+      long_desc <<-LONG_DESC
+        Displays the DSU entries for today. This command has no options.
+      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
+      end
+
+      desc 'tomorrow, t',
+        'Displays the DSU entries for tomorrow'
+      long_desc <<-LONG_DESC
+        Displays the DSU entries for tomorrow. This command has no options.
+      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
+      end
+
+      desc 'yesterday, y',
+        'Displays the DSU entries for yesterday'
+      long_desc <<-LONG_DESC
+        Displays the DSU entries for yesterday. This command has no options.
+      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
+      end
+
+      desc 'date, d DATE',
+        'Displays the DSU entries for DATE'
+      long_desc <<-LONG_DESC
+      Displays the DSU entries for DATE.
+        \x5 #{date_option_description}
+      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
+        end
+      rescue ArgumentError => e
+        say "Error: #{e.message}", ERROR
+        exit 1
+      end
+    end
+  end
+end

data/lib/dsu/support/configuration.rb

@@ -18,11 +18,16 @@ module Dsu
 
       # rubocop:disable Style/StringHashKeys - YAML writing/loading necessitates this
       DEFAULT_DSU_OPTIONS = {
+        # 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',
         'entries_file_name' => '%Y-%m-%d.json',
-        'entries_folder' => "#{FolderLocations.root_folder}/dsu/entries",
+        'entries_folder' => "#{FolderLocations.root_folder}/dsu/entries"
       }.freeze
       # rubocop:enable Style/StringHashKeys
 
@@ -43,6 +48,7 @@ module Dsu
         delete_config_file config_file: config_file
       end
 
+      # TODO: Move this to a view (e.g. views/configuration/show.rb)
       def print_config_file
         if config_file?
           say "Config file (#{config_file}) contents:", SUCCESS
@@ -50,6 +56,11 @@ module Dsu
           say hash.to_yaml.gsub("\n-", "\n\n-"), SUCCESS
         else
           say "Config file (#{config_file}) does not exist.", WARNING
+          say ''
+          say 'The default configuration is being used:'
+          DEFAULT_DSU_OPTIONS.each_with_index do |config_entry, index|
+            say "#{index + 1}. #{config_entry[0]}: '#{config_entry[1]}'"
+          end
         end
       end
 

data/lib/dsu/support/entry_group_viewable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module EntryGroupViewable
+      module_function
+
+      def view_entry_group(time:)
+        entry_group = if Models::EntryGroup.exists?(time: time)
+          entry_group_json = Services::EntryGroupReaderService.new(time: time).call
+          Services::EntryGroupHydratorService.new(entry_group_json: entry_group_json).call
+        else
+          Models::EntryGroup.new(time: time)
+        end
+        Views::EntryGroup::Show.new(entry_group: entry_group).render
+      end
+    end
+  end
+end

data/lib/dsu/support/time_formatable.rb

@@ -13,29 +13,23 @@ module Dsu
       def formatted_time(time:)
         time = time.localtime if time.utc?
 
-        today_yesterday_or_tomorrow = if today?(time: time)
+        today_yesterday_or_tomorrow = if time.today?
           'Today'
-        elsif yesterday?(time: time)
+        elsif time.yesterday?
           'Yesterday'
-        elsif tomorrow?(time: time)
+        elsif time.tomorrow?
           'Tomorrow'
         end
 
-        return time.strftime('%A, %Y-%m-%d') unless today_yesterday_or_tomorrow
+        time_zone = timezone_for(time: time)
 
-        time.strftime("%A, (#{today_yesterday_or_tomorrow}) %Y-%m-%d")
-      end
-
-      def today?(time:)
-        time.strftime('%Y%m%d') == Time.now.strftime('%Y%m%d')
-      end
+        return time.strftime("%A, %Y-%m-%d #{time_zone}") unless today_yesterday_or_tomorrow
 
-      def yesterday?(time:)
-        time.strftime('%Y%m%d') == 1.day.ago(Time.now).strftime('%Y%m%d')
+        time.strftime("%A, (#{today_yesterday_or_tomorrow}) %Y-%m-%d #{time_zone}")
       end
 
-      def tomorrow?(time:)
-        time.strftime('%Y%m%d') == 1.day.from_now(Time.now).strftime('%Y%m%d')
+      def timezone_for(time:)
+        time.zone
       end
     end
   end

data/lib/dsu/support/times_sortable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module TimesSortable
+      module_function
+
+      def times_sort(times:, entries_display_order: nil)
+        entries_display_order ||= 'asc'
+        unless %w[asc desc].include? entries_display_order
+          raise "Invalid entries_display_order: #{entries_display_order}"
+        end
+
+        if entries_display_order == 'asc'
+          times.sort # sort ascending
+        elsif entries_display_order == 'desc'
+          times.sort.reverse # sort descending
+        end
+      end
+
+      def times_for(times:)
+        start_date = times.max
+        return times unless start_date.monday? || start_date.on_weekend?
+
+        # (0..3).map { |num| start_date - num.days }
+        # (start_date..-start_date.friday?).map { |time| time }
+        # (0..3).map { |num| start_date - num.days if start_date.on_weekend? || start_date.monday? }
+        # If the start_date is a weekend or a Monday, then we need to include
+        # start_date along with all the dates up to and including the previous
+        # Monday.
+        (0..3).filter_map do |num|
+          time = start_date - num.days
+          next unless time == start_date || time.on_weekend? || time.friday?
+
+          time
+        end
+      end
+    end
+  end
+end

data/lib/dsu/validators/entries_validator.rb

@@ -12,14 +12,14 @@ module Dsu
       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? { |field| field.is_a? Symbol }
+        raise 'options[:fields] elements are not Symbols.' unless options[:fields].all?(Symbol)
 
         options[:fields].each do |field|
           entries = record.send(field)
 
           unless entries.is_a?(Array)
             record.errors.add(field, 'is the wrong object type. ' \
-                  "\"Array\" was expected, but \"#{entries.class}\" was received.")
+                                     "\"Array\" was expected, but \"#{entries.class}\" was received.")
             next
           end
 
@@ -35,7 +35,7 @@ module Dsu
           next if 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.",
+                                   "\"Entry\" was expected, but \"#{entry.class}\" was received.",
             type: Dsu::Support::FieldErrors::FIELD_TYPE_ERROR)
 
           next
@@ -47,16 +47,13 @@ module Dsu
 
         entry_objects = entries.select { |entry| entry.is_a?(Dsu::Models::Entry) }
 
-        entry_objects.map(&:uuid).tap do |uuids|
-          return if uuids.uniq.length == uuids.length
-        end
+        uuids = entry_objects.map(&:uuid)
+        return if uuids.uniq.length == uuids.length
 
-        entry_objects.map(&:uuid).tap do |uuids|
-          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)
-          end
+        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)
         end
       end
     end

data/lib/dsu/version.rb

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

data/lib/dsu/views/entry_group/edit.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'active_support/core_ext/numeric/time'
+require_relative '../../models/entry_group'
+require_relative '../../support/colorable'
+require_relative '../../support/say'
+require_relative '../../support/time_formatable'
+
+module Dsu
+  module Views
+    module EntryGroup
+      class Edit
+        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 nil' if options.nil?
+          raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash)
+
+          @entry_group = entry_group
+          @options = options || {}
+        end
+
+        def call
+          # Just in case the entry group is invalid, we'll
+          # validate it before displaying it.
+          entry_group.validate!
+          render_entry_group!
+        rescue ActiveModel::ValidationError
+          puts "Error(s) encountered: #{entry_group.errors.full_messages}"
+          raise
+        end
+        alias render call
+
+        private
+
+        attr_reader :entry_group, :options
+
+        def render_entry_group!
+          say "# Editing DSU Entries for #{formatted_time(time: entry_group.time)}"
+          say('(no entries available for this day)') and return if entry_group.entries.empty?
+
+          say ''
+          say '# [SHA/COMMAND] [DESCRIPTION]'
+
+          entry_group.entries.each do |entry|
+            say "#{entry.uuid} #{entry.description}"
+          end
+
+          say ''
+          say '# INSTRUCTIONS:'
+          say '# ADD a DSU entry: use one of the following commands: [+|a|add] ' \
+              'followed by the description.'
+          say '# EDIT a DSU entry: change the description.'
+          say '# DELETE a DSU entry: delete the entry or replace the sha with one ' \
+              'of the following commands: [-|d|delete].'
+          say '# NOTE: deleting all the entries will delete the entry group file; '
+          say '#       this is preferable if this is what you want to do :)'
+          say '# REORDER a DSU entry: reorder the DSU entries in order preference.'
+          say '#'
+          say '# *** When you are done, save and close your editor ***'
+        end
+      end
+    end
+  end
+end