dsu 0.1.0.alpha.1

data/lib/dsu/cli.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'bundler'
+require 'thor'
+require_relative 'command_services/add_entry_service'
+require_relative 'models/entry_group'
+require_relative 'services/configuration_loader_service'
+require_relative 'services/entry_group_hydrator_service'
+require_relative 'services/entry_group_reader_service'
+require_relative 'subcommands/config'
+require_relative 'version'
+require_relative 'views/entry_group/show'
+
+module Dsu
+  #
+  # The `dsu` command.
+  #
+  class CLI < ::Thor
+    class_option :debug, type: :boolean, default: false
+
+    map %w[--version -v] => :version
+    # map %w[--interactive -i] => :interactive
+
+    default_command :help
+
+    class << self
+      def exit_on_failure?
+        false
+      end
+    end
+
+    def initialize(*args)
+      super
+
+      @configuration = Services::ConfigurationLoaderService.new.call
+    end
+
+    desc 'add [OPTIONS] DESCRIPTION [LONG-DESCRIPTION]',
+      'Adds a dsu entry for the date associated with the given option.'
+    long_desc <<-LONG_DESC
+      TBD
+    LONG_DESC
+    option :date, type: :string, aliases: '-d'
+    option :next_day, type: :boolean, aliases: '-n'
+    option :previous_day, type: :boolean, aliases: '-p'
+    option :today, type: :boolean, aliases: '-t', default: true
+
+    def add(description, long_description = nil)
+      entry = Models::Entry.new(description: description, long_description: long_description)
+      time = if options[:date].present?
+        Time.parse(options[:date])
+      elsif options[:next_day].present?
+        1.day.from_now
+      elsif options[:previous_day].present?
+        1.day.ago
+      elsif options[:today].present?
+        Time.now
+      else
+        raise 'No date option specified.'
+      end
+      display_entry_group(time: 1.day.ago(time))
+      puts
+      CommandServices::AddEntryService.new(entry: entry, time: time).call
+      display_entry_group(time: time)
+    end
+
+    desc 'today',
+      '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
+      sort_times(times: [1.day.ago(time), time]).each do |time| # rubocop:disable Lint/ShadowingOuterLocalVariable
+        display_entry_group(time: time)
+        puts
+      end
+    end
+
+    desc 'tomorrow',
+      '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
+      sort_times(times: [1.day.from_now(time), time]).each do |time| # rubocop:disable Lint/ShadowingOuterLocalVariable
+        display_entry_group(time: time)
+        puts
+      end
+    end
+
+    desc 'yesterday',
+      '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
+      sort_times(times: [1.day.ago(time), 2.days.ago(time)]).each do |time| # rubocop:disable Lint/ShadowingOuterLocalVariable
+        display_entry_group(time: time)
+        puts
+      end
+    end
+
+    desc 'date',
+      'Displays the dsu entries for DATE.'
+    long_desc <<-LONG_DESC
+      Displays the dsu entries for DATE, where DATE is any date string that can be parsed using `Time.parse`. For example: `require 'time'; Time.parse("2023-01-01")`.
+    LONG_DESC
+    def date(date)
+      time = Time.parse(date)
+      sort_times(times: [1.day.ago(time), time]).each do |time| # rubocop:disable Lint/ShadowingOuterLocalVariable
+        display_entry_group(time: time)
+        puts
+      end
+    end
+
+    # TODO: Implement this.
+    # desc 'interactive', 'Opens a dsu interactive session'
+    # long_desc ''
+    # option :next_day, type: :boolean, aliases: '-n'
+    # option :previous_day, type: :boolean, aliases: '-p'
+    # option :today, type: :boolean, aliases: '-t'
+
+    # # https://stackoverflow.com/questions/4604905/interactive-prompt-with-thor
+    # def interactive
+    #   exit_commands = %w[x q exit quit]
+    #   display_interactive_help
+    #   loop do
+    #     command = ask('dsu > ')
+    #     display_interactive_help if command == 'h'
+    #     break if exit_commands.include? command
+    #   end
+    #   say 'Done.'
+    # end
+
+    desc 'config SUBCOMMAND', 'Manage configuration file for this gem'
+    subcommand :config, Subcommands::Config
+
+    desc '--version, -v', 'Displays this gem version'
+    def version
+      say VERSION
+    end
+
+    private
+
+    attr_reader :configuration
+
+    def display_interactive_help
+      say 'Interactive Mode Commands:'
+      say '---'
+      say '[h]: show this help screen'
+      say '[n]: next day'
+      say '[p]: previous day'
+      say '[t]: today'
+      say '[x|q|exit|quit]: Exit interactive mode'
+    end
+
+    def display_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).display
+    end
+
+    def sort_times(times:)
+      if configuration[:entries_display_order] == 'asc'
+        times.sort # sort ascending
+      elsif configuration[:entries_display_order] == 'desc'
+        times.sort.reverse # sort descending
+      end
+    end
+  end
+end

data/lib/dsu/command_services/add_entry_service.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../services/entry_group_writer_service'
+require_relative '../models/entry'
+require_relative '../support/entry_group_loadable'
+require_relative '../support/folder_locations'
+
+module Dsu
+  module CommandServices
+    # This class adds (does NOT update) an entry to an entry group.
+    class AddEntryService
+      include Dsu::Support::EntryGroupLoadable
+      include Dsu::Support::FolderLocations
+
+      attr_reader :entry, :entry_group, :time
+
+      # :entry is an Entry object
+      # :time is a Time object; the time of the entry group.
+      def initialize(entry:, time:)
+        raise ArgumentError, 'entry is nil' if entry.nil?
+        raise ArgumentError, 'entry is the wrong object type' unless entry.is_a?(Dsu::Models::Entry)
+        raise ArgumentError, 'time is nil' if time.nil?
+        raise ArgumentError, 'time is the wrong object type' unless time.is_a?(Time)
+
+        @entry = entry
+        @time = time
+        @entry_group = Dsu::Models::EntryGroup.load(time: time)
+      end
+
+      def call
+        entry.validate!
+        save_entry_group!
+        entry.uuid
+      rescue ActiveModel::ValidationError
+        puts "Error(s) encountered: #{entry.errors.full_messages}"
+        raise
+      end
+
+      private
+
+      attr_writer :entry, :entry_group, :time
+
+      def entry_exists?
+        @entry_exists ||= entry_group.entries.include? entry.uuid
+      end
+
+      def entry_group_hash
+        @entry_group_hash ||= entry_group_hash_for time: time
+      end
+
+      def save_entry_group!
+        raise "Entry #{entry.uuid} already exists in entry group #{time}" if entry_exists?
+
+        entry_group.entries << entry
+        entry_group.validate!
+
+        Dsu::Services::EntryGroupWriterService.new(entry_group: entry_group).call
+      end
+    end
+  end
+end

data/lib/dsu/models/entry.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'deco_lite'
+require 'securerandom'
+
+module Dsu
+  module Models
+    class Entry < DecoLite::Model
+      validates :uuid, presence: true, format: {
+        with: /\A[0-9a-f]{8}\z/i,
+        message: 'is the wrong format. ' \
+                 '0-9, a-f, and 8 characters were expected.' \
+      }
+      validates :description, presence: true, length: { minimum: 2, maximum: 80 }
+      validates :long_description, length: { minimum: 2, maximum: 256 }, allow_nil: true
+
+      def initialize(description:, uuid: nil, long_description: nil)
+        raise ArgumentError, 'description is nil' if description.nil?
+        raise ArgumentError, 'description is the wrong object type' unless description.is_a?(String)
+        raise ArgumentError, 'uuid is the wrong object type' unless uuid.is_a?(String) || uuid.nil?
+        raise ArgumentError, 'long_description is the wrong object type' unless long_description.is_a?(String) || long_description.nil?
+
+        uuid ||= SecureRandom.uuid[0..7]
+
+        super(hash: {
+          uuid: uuid,
+          description: description,
+          long_description: long_description
+        })
+      end
+
+      def required_fields
+        %i[uuid description]
+      end
+
+      def long_description?
+        long_description.present?
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Entry)
+
+        uuid == other.uuid &&
+          description == other.description &&
+          long_description == other.long_description
+      end
+    end
+  end
+end

data/lib/dsu/models/entry_group.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'deco_lite'
+require_relative '../support/entry_group_loadable'
+require_relative '../services/entry_group_reader_service'
+require_relative '../validators/entries_validator'
+require_relative '../validators/time_validator'
+
+module Dsu
+  module Models
+    class EntryGroup < DecoLite::Model
+      extend Support::EntryGroupLoadable
+
+      validates_with Validators::EntriesValidator, fields: [:entries]
+      validates_with Validators::TimeValidator, fields: [:time]
+
+      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
+        })
+      end
+
+      class << self
+        def exists?(time:)
+          Dsu::Services::EntryGroupReaderService.entry_group_file_exists?(time: time)
+        end
+
+        def load(time: nil)
+          new(**hydrated_entry_group_hash_for(time: time))
+        end
+
+        # This function returns a hash whose :time and :entries
+        # key values are hydrated with instantiated Time and Entry
+        # objects.
+        def hydrated_entry_group_hash_for(time:)
+          entry_group_hash = entry_group_hash_for(time: time)
+          hydrate_entry_group_hash(entry_group_hash: entry_group_hash, time: time)
+        end
+      end
+
+      def required_fields
+        %i[time entries]
+      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 to_h_localized
+        to_h.tap do |hash|
+          hash[:time] = hash[:time].localtime
+        end
+      end
+    end
+  end
+end

data/lib/dsu/services/configuration_loader_service.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'yaml'
+require_relative '../support/configuration'
+
+module Dsu
+  module Services
+    class ConfigurationLoaderService
+      include Dsu::Support::Configuration
+
+      attr_reader :default_options
+
+      def initialize(default_options: Dsu::Support::Configuration::DEFAULT_DSU_OPTIONS)
+        @default_options = default_options
+      end
+
+      def call
+        load_config.merge(default_options || {}).presence&.with_indifferent_access || raise('No configuration options found')
+      end
+
+      private
+
+      attr_writer :default_options
+
+      def load_config
+        return {} unless config_file?
+
+        yaml_options = File.read(config_file)
+        YAML.safe_load ERB.new(yaml_options).result
+      end
+    end
+  end
+end

data/lib/dsu/services/entry_group_deleter_service.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../support/entry_group_fileable'
+
+# This class is responsible for deleting an entry group file.
+module Dsu
+  module Services
+    class EntryGroupDeleterService
+      include Dsu::Support::EntryGroupFileable
+
+      def initialize(time:, options: {})
+        @time = time
+        @options = options || {}
+      end
+
+      def call
+        delete_entry_group_file!
+      end
+
+      private
+
+      attr_reader :time, :options
+
+      def delete_entry_group_file!
+        return unless entry_group_file_exists?
+
+        File.delete(entry_group_file_path)
+      end
+    end
+  end
+end

data/lib/dsu/services/entry_group_hydrator_service.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'entry_hydrator_service'
+
+module Dsu
+  module Services
+    class EntryGroupHydratorService
+      def initialize(entry_group_json:, options: {})
+        raise ArgumentError, 'entry_group_json is nil' if entry_group_json.nil?
+        raise ArgumentError, 'entry_group_json is the wrong object type' unless entry_group_json.is_a?(String)
+        raise ArgumentError, 'options is nil' if options.nil?
+        raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash)
+
+        @entry_group_json = entry_group_json
+        @options = options || {}
+      end
+
+      def call
+        entry_group_hash = to_h
+        Dsu::Models::EntryGroup.new(**entry_group_hash)
+      end
+
+      class << self
+        # Returns a Hash with :time and :entries values hydrated
+        # (i.e. Time and Entry objects respectively).
+        def to_h(entry_group_json:, options: {})
+          JSON.parse(entry_group_json, symbolize_names: true).tap do |hash|
+            hash[:time] = Time.parse(hash[:time])
+            hash[:entries] = EntryHydratorService.hydrate(entries_array: hash[:entries], options: options)
+          end
+        end
+      end
+
+      private
+
+      attr_reader :entry_group_json, :options
+
+      def to_h
+        self.class.to_h(entry_group_json: entry_group_json, options: options)
+      end
+    end
+  end
+end

data/lib/dsu/services/entry_group_reader_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../support/entry_group_fileable'
+
+module Dsu
+  module Services
+    class EntryGroupReaderService
+      include Dsu::Support::EntryGroupFileable
+
+      def initialize(time:, options: {})
+        @time = time
+        @options = options || {}
+      end
+
+      def call
+        read_entry_group_file
+      end
+
+      class << self
+        def entry_group_file_exists?(time:, options: {})
+          new(time: time, options: options).send(:entry_group_file_exists?)
+        end
+      end
+
+      private
+
+      attr_reader :time, :options
+
+      def read_entry_group_file
+        return {} unless entry_group_file_exists?
+
+        File.read(entry_group_file_path)
+      end
+    end
+  end
+end

data/lib/dsu/services/entry_group_writer_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'active_support/core_ext/module/delegation'
+require_relative '../models/entry_group'
+require_relative '../support/entry_group_fileable'
+
+module Dsu
+  module Services
+    class EntryGroupWriterService
+      include Dsu::Support::EntryGroupFileable
+
+      delegate :time, to: :entry_group
+
+      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?(Dsu::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
+        entry_group.validate!
+        create_entry_group_path_if!
+        write_entry_group_to_file!
+      rescue ActiveModel::ValidationError
+        puts "Error(s) encountered: #{entry_group.errors.full_messages}"
+        raise
+      end
+
+      private
+
+      attr_reader :entry_group, :options
+
+      def write_entry_group_to_file!
+        create_entry_group_path_if!
+        File.write(entry_group_file_path, JSON.pretty_generate(entry_group.to_h))
+        puts "Wrote group entry file: #{entry_group_file_path}" if ENV['ENV_DEV']
+      end
+    end
+  end
+end

data/lib/dsu/services/entry_hydrator_service.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../models/entry'
+
+module Dsu
+  module Services
+    class EntryHydratorService
+      def initialize(entry_hash:, options: {})
+        raise ArgumentError, 'entry_hash is nil' if entry_hash.nil?
+        raise ArgumentError, 'entry_hash is the wrong object type' unless entry_hash.is_a?(Hash)
+        raise ArgumentError, 'options is nil' if options.nil?
+        raise ArgumentError, 'options is the wrong object type' unless options.is_a?(Hash)
+
+        @entry_hash = entry_hash
+        @options = options || {}
+      end
+
+      def call
+        Dsu::Models::Entry.new(**entry_hash)
+      end
+
+      class << self
+        def hydrate(entries_array:, options: {})
+          entries_array.map do |entry_hash|
+            new(entry_hash: entry_hash, options: options).call
+          end
+        end
+      end
+
+      private
+
+      attr_reader :entry_hash, :options
+    end
+  end
+end

data/lib/dsu/subcommands/config.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative '../support/configuration'
+
+module Dsu
+  module Subcommands
+    class Config < ::Thor
+      include Dsu::Support::Configuration
+
+      default_command :help
+
+      class << self
+        def exit_on_failure?
+          false
+        end
+      end
+
+      desc 'info', 'Displays information about this gem configuration'
+      long_desc <<-LONG_DESC
+        NAME
+        \x5
+        `dsu config info` -- Displays information about this gem configuration.
+
+        SYNOPSIS
+        \x5
+        dsu config info
+      LONG_DESC
+      def info
+        print_config_file
+      end
+
+      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.
+
+        SYNOPSIS
+        \x5
+        dsu config init
+      LONG_DESC
+      def init
+        create_config_file!
+      end
+    end
+  end
+end

data/lib/dsu/support/ask.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Dsu
+  module Support
+    module Ask
+      ASK_YES = %w[y yes].freeze
+      # ASK_NO = %w[n no].freeze
+      # ASK_CANCEL = %w[c cancel].freeze
+      # ASK_YES_NO_CANCEL = ASK_YES.concat(ASK_NO).concat(ASK_CANCEL).freeze
+
+      def ask(prompt)
+        options = {}
+        Thor::LineEditor.readline(prompt, options)
+      end
+
+      def yes?(prompt, color = nil)
+        Thor::Base.shell.new.yes?(prompt, color)
+      end
+
+      # def no?(prompt)
+      #   ask_with(prompt: prompt, values: ASK_NO)
+      # end
+
+      # def yes_no_cancel(prompt)
+      #   ask_with(prompt: prompt, values: ASK_YES_NO_CANCEL)
+      # end
+
+      # private
+
+      # def ask_with(prompt:, values:)
+      #   p "#{prompt}"
+      #   values.include? STDIN.gets.chomp
+      # end
+    end
+  end
+end

data/lib/dsu/support/colorable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module Colorable
+      ABORTED = :red
+      ERROR = :red
+      HIGHLIGHT = :cyan
+      SUCCESS = :green
+      WARNING = :yellow
+    end
+  end
+end