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

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module CommandOptions
+      # The purpose of this module is to take a command option that is a string and return a Time object.
+      # The command option is expected to be a date in the format of [M]M/[D]D[/YYYY]. MM and DD with
+      # leading zeroes is optional (i.e. only M and D are required), YYYY is optionl and will be replaced
+      # with the current year if not provided.
+      module Time
+        DATE_CAPTURE_REGEX = %r{\A(?<month>0?[1-9]|1[0-2])/(?<day>0?[1-9]|1\d|2\d|3[01])(?:/(?<year>\d{4}))?\z}
+
+        def time_from_date_string!(command_option:)
+          raise ArgumentError, 'command_option is nil.' if command_option.nil?
+          raise ArgumentError, 'command_option is blank.' if command_option.blank?
+
+          unless command_option.is_a?(String)
+            raise ArgumentError, "command_option is not a String: \"#{command_option}\"."
+          end
+
+          time_parts = time_parts_for(time_string: command_option)
+          return unless time_parts?(time_parts: time_parts)
+
+          valid_time!(time_parts: time_parts)
+
+          # This will rescue errors resulting from calling Date.strptime with an invalid date string,
+          # and return a more meaningful error message.
+        rescue DateTime::Error
+          raise ArgumentError, "command_option is not a valid date: \"#{command_option}\"."
+        end
+
+        def time_from_date_string(command_option:)
+          time_from_date_string!(command_option: command_option)
+        rescue ArgumentError
+          nil
+        end
+
+        private
+
+        # This method returns the time parts for the given time string in a hash
+        # (i.e. month, day, year) IF the time string matches the DATE_CAPTURE_REGEX
+        # regex. Otherwise, it returns an empty hash.
+        def time_parts_for(time_string:)
+          match_data = DATE_CAPTURE_REGEX.match(time_string)
+          return {} if match_data.nil?
+
+          {
+            month: match_data[:month],
+            day: match_data[:day],
+            year: match_data[:year]
+          }
+        end
+
+        # This method returns true if the date passes the DATE_CAPTURE_REGEX regex match
+        # in #date_parts_for and returns a non-nil hash. Otherwise, it returns false.
+        # A non-nil hash returned from #date_parts_for doesn necessarily mean the date
+        # parts will equate to a valid date when parsed, it just means the date string
+        # matched the regex. Calling #valid_date! will raise an ArgumentError if the
+        # date parts do not equate to a valid date.
+        def time_parts?(time_parts:)
+          !time_parts.empty?
+        end
+
+        def valid_time!(time_parts:)
+          time_string = time_string_for(time_parts: time_parts)
+          Date.strptime(time_string, '%Y/%m/%d').to_time
+        end
+
+        def time_string_for(time_parts:)
+          # Replace the year with the current year if it is nil.
+          time_parts[:year] = ::Time.now.year if time_parts[:year].nil?
+          "#{time_parts[:year]}/#{time_parts[:month]}/#{time_parts[:day]}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'time_mneumonics'
+
+module Dsu
+  module Support
+    module CommandOptions
+      # The purpose of this module is to take a command option that is a string and return a Time object.
+      # The command option is expected to be a time mneumoic.
+      module TimeMneumonic
+        include TimeMneumonics
+
+        def time_from_mneumonic(command_option:, relative_time: nil)
+          time_from_mneumonic!(command_option: command_option, relative_time: relative_time)
+        rescue ArgumentError
+          nil
+        end
+
+        # command_option: is expected to me a time mneumonic. If relative_time is NOT nil, all
+        # time mneumonics are relative to relative_time. Otherwise, they are relative to Time.now.
+        # relative_time: is a Time object that is required IF command_option is expected to be
+        # a relative time mneumonic. Otherwise, it is optional.
+        def time_from_mneumonic!(command_option:, relative_time: nil)
+          validate_argument!(command_option: command_option, command_option_name: :command_option)
+          unless relative_time.nil?
+            validate_argument!(command_option: relative_time, command_option_name: :relative_time)
+          end
+
+          # if relative_time_mneumonic?(command_option) && !relative_time.nil?
+          #   # If command_option is a relative time mneumonic, we need to get the time
+          #   # relative to relative_time using ::Time.now, and use the command_option
+          #   # as the relative time.
+          #   return time_from_mneumonic!(command_option: relative_time, relative_time: command_option)
+          # end
+
+          time_for_mneumonic(mneumonic: command_option, relative_time: relative_time)
+        end
+
+        # This method returns true if mneumonic is a valid mneumonic OR
+        # a relative time mneumonic.
+        def time_mneumonic?(mneumonic)
+          mneumonic?(mneumonic) || relative_time_mneumonic?(mneumonic)
+        end
+
+        private
+
+        # Returns a Time object from a mneumonic.
+        def time_for_mneumonic(mneumonic:, relative_time: nil)
+          # If relative_time is a relative time mneumonic, then we need to first
+          # convert mneumonic to a Time object first, so that we can calculate
+          # `relative_time.to_i.days.from_now(time)` to get the correct Time we
+          # need.
+          if relative_time_mneumonic?(relative_time)
+            time = time_for_mneumonic(mneumonic: mneumonic)
+            return relative_time_for(days_from_now: relative_time, time: time)
+          end
+
+          if mneumonic?(mneumonic) && mneumonic?(relative_time)
+            time = time_for_mneumonic(mneumonic: mneumonic)
+
+            # Simply return the time if relative_time is 'today'
+            # because 'today' relative to any time will always
+            # point to itself.
+            return time if today_mneumonic?(relative_time)
+
+            return time.public_send(relative_time)
+          end
+
+          time = ::Time.now
+          if today_mneumonic?(mneumonic)
+            time
+          elsif tomorrow_mneumonic?(mneumonic)
+            time.tomorrow
+          elsif yesterday_mneumonic?(mneumonic)
+            time.yesterday
+          elsif relative_time_mneumonic?(mneumonic)
+            relative_time_for(days_from_now: mneumonic, time: time)
+          end
+        end
+
+        def relative_time_for(days_from_now:, time:)
+          days_from_now.to_i.days.from_now(time)
+        end
+
+        # This method returns true if mneumonic is a valid time mneumonic.
+        # This method will return false if mneumonic is an invalid mneumonic
+        # OR if mneumonic is a relative time mneumonic.
+        def mneumonic?(mneumonic)
+          today_mneumonic?(mneumonic) ||
+            tomorrow_mneumonic?(mneumonic) ||
+            yesterday_mneumonic?(mneumonic)
+        end
+
+        # This method returns true if mneumonic is a valid relative
+        # time mneumonic.
+        def relative_time_mneumonic?(mneumonic)
+          return false unless mneumonic.is_a?(String)
+
+          mneumonic.match?(RELATIVE_REGEX)
+        end
+
+        def today_mneumonic?(mneumonic)
+          TODAY.include?(mneumonic)
+        end
+
+        def tomorrow_mneumonic?(mneumonic)
+          TOMORROW.include?(mneumonic)
+        end
+
+        def yesterday_mneumonic?(mneumonic)
+          YESERDAY.include?(mneumonic)
+        end
+
+        def validate_argument!(command_option:, command_option_name:)
+          raise ArgumentError, "#{command_option_name} cannot be nil." if command_option.nil?
+          raise ArgumentError, "#{command_option_name} cannot be blank." if command_option.blank?
+          unless command_option.is_a?(String)
+            raise ArgumentError, "#{command_option_name} must be a String: \"#{command_option}\""
+          end
+          unless time_mneumonic?(command_option)
+            raise ArgumentError, "#{command_option_name} is an invalid mneumonic: \"#{command_option}\"."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module CommandOptions
+      module TimeMneumonics
+        TODAY = %w[n today].freeze
+        TOMORROW = %w[t tomorrow].freeze
+        YESERDAY = %w[y yesterday].freeze
+
+        RELATIVE_REGEX = /[+-]\d+/
+      end
+    end
+  end
+end

data/lib/dsu/support/configurable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../services/configuration_loader_service'
+
+module Dsu
+  module Support
+    # This module provides a way to configure a class, so that it can
+    # be used in a test environment.
+    module Configurable
+      def configuration
+        @configuration ||= Services::ConfigurationLoaderService.new.call
+      end
+    end
+  end
+end

data/lib/dsu/support/configuration.rb

@@ -27,7 +27,19 @@ module Dsu
         # 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",
+        'carry_over_entries_to_today' => false,
+        # If true, when using dsu commands that list date ranges (e.g.
+        # `dsu list dates`), the displayed list will include dates that
+        # have no dsu entries. If false, the displayed list will only
+        # include dates that have dsu entries.
+        # For all other `dsu list` commands, if true, this option will
+        # behave in the aforementioned manner. If false, the displayed
+        # list will unconditionally display the first and last dates
+        # regardless of whether or not the DSU date has entries or not;
+        # all other dates will not be displayed if the DSU date has no
+        # entries.
+        'include_all' => false
       }.freeze
       # rubocop:enable Style/StringHashKeys
 

data/lib/dsu/support/entry_group_fileable.rb

@@ -1,14 +1,39 @@
 # frozen_string_literal: true
 
 require_relative '../services/configuration_loader_service'
+require_relative '../support/configurable'
 
 module Dsu
   module Support
+    # TODO: I hate this module; refactor it!!!
+    # This module expects the following attributes to be defined: :time, :options
     module EntryGroupFileable
-      module_function
+      extend Support::Configurable
+
+      class << self
+        def entry_group_file_exists?(time:)
+          File.exist?(entry_group_file_path(time: time))
+        end
+
+        def entry_group_file_path(time:)
+          File.join(entries_folder, entries_file_name(time: time))
+        end
+
+        def entries_folder
+          configuration[:entries_folder]
+        end
+
+        def entries_file_name(time:)
+          time.strftime(configuration[:entries_file_name])
+        end
+
+        # def configuration
+        #   Services::ConfigurationLoaderService.new.call
+        # end
+      end
 
       def entry_group_file_exists?
-        File.exist?(entry_group_file_path)
+        EntryGroupFileable.entry_group_file_exists?(time: time)
       end
 
       def entry_group_path_exists?
@@ -16,15 +41,15 @@ module Dsu
       end
 
       def entry_group_file_path
-        File.join(entries_folder, entries_file_name)
+        EntryGroupFileable.entry_group_file_path(time: time)
       end
 
       def entries_folder
-        @entries_folder ||= configuration[:entries_folder]
+        @entries_folder ||= EntryGroupFileable.entries_folder
       end
 
       def entries_file_name
-        @entries_file_name ||= time.strftime(configuration[:entries_file_name])
+        @entries_file_name ||= EntryGroupFileable.entries_file_name(time: time)
       end
 
       def create_entry_group_path_if!
@@ -34,7 +59,7 @@ module Dsu
       private
 
       def configuration
-        @configuration ||= options[:configuration] || Services::ConfigurationLoaderService.new.call
+        @configuration ||= options[:configuration] || EntryGroupFileable.configuration
       end
     end
   end

data/lib/dsu/support/entry_group_loadable.rb

@@ -3,30 +3,27 @@
 require 'pathname'
 require_relative '../services/entry_group_reader_service'
 require_relative '../models/entry'
+require_relative '../models/entry_group'
 
 module Dsu
   module Support
     module EntryGroupLoadable
-      module_function
-
-      # 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:)
+      # returns an EntryGroup object loaded from
+      # the entry group json file.
+      def load(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
+      module_function
 
       # Accepts an entry group hash and returns a
       # hydrated entry group hash:
@@ -39,10 +36,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/support/entry_group_viewable.rb

@@ -3,17 +3,35 @@
 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)
+      def view_entry_groups(times:, options: {})
+        total_viewable_entry_groups = 0
+
+        times.each do |time|
+          view_entry_group(time: time, options: options) do
+            total_viewable_entry_groups += 1
+            puts
+          end
         end
+
+        yield total_viewable_entry_groups if block_given?
+      end
+
+      def view_entry_group(time:, options: {})
+        return unless show_entry_group?(time: time, options: options)
+
+        entry_group = Models::EntryGroup.load(time: time)
         Views::EntryGroup::Show.new(entry_group: entry_group).render
+
+        yield if block_given?
       end
+
+      private
+
+      def show_entry_group?(time:, options:)
+        Models::EntryGroup.exists?(time: time) || options[:include_all]
+      end
+
+      module_function :view_entry_group, :view_entry_groups, :show_entry_group?
     end
   end
 end

data/lib/dsu/support/times_sortable.rb

@@ -18,13 +18,11 @@ module Dsu
         end
       end
 
+      # TODO: Do we have something else we can use here?
       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.

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.1.0.alpha.1'
 end

data/lib/dsu/views/edited_entries/shared/errors.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../shared/messages'
+
+module Dsu
+  module Views
+    module EditedEntries
+      module Shared
+        class Errors
+          def initialize(edited_entries:, options: {})
+            raise ArgumentError, 'edited_entries is nil' if edited_entries.nil?
+            raise ArgumentError, 'edited_entries is the wrong object type' unless edited_entries.is_a?(Array)
+            unless edited_entries.all?(Models::EditedEntry)
+              raise ArgumentError, 'edited_entries elements are the wrong object type'
+            end
+            raise ArgumentError, 'options is nil' if options.nil?
+            raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash)
+
+            @edited_entries = edited_entries
+            @options = options || {}
+            @header = options[:header] || 'The following ERRORS were encountered; these changes were not saved:'
+          end
+
+          def render
+            return if edited_entries.empty?
+            return if edited_entries.all?(&:valid?)
+
+            messages = edited_entries.map { |edited_entry| edited_entry.errors.full_messages }.flatten
+            Views::Shared::Messages.new(messages: messages, message_type: :error, options: { header: header }).render
+          end
+
+          private
+
+          attr_reader :edited_entries, :header, :options
+        end
+      end
+    end
+  end
+end