dsu 0.1.0.alpha.1

data/lib/dsu/support/commander/command.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative 'command_help'
+require_relative 'subcommand'
+
+module Dsu
+  module Support
+    module Commander
+      # https://www.toptal.com/ruby/ruby-dsl-metaprogramming-guide
+      module Command
+        class << self
+          def included(base)
+            base.extend ClassMethods
+            base.engine.command_namespace to_command_namespace_symbol base.name
+            base.engine.command_prompt base.engine.command_namespace
+            binding.pry
+            base.singleton_class.delegate :command_namespace, :command_namespaces, :commands,
+              :command_add, :command_subcommand_add, :command_prompt, :command_parent,
+              :help, to: :engine
+          end
+
+          private
+
+          def to_command_namespace_symbol(namespace, join_token: '_')
+            namespace.delete(':').split(/(?=[A-Z])/).join(join_token).downcase
+          end
+        end
+
+        module ClassMethods
+          def command_subcommand_create(command_parent:)
+            new.tap do |subcommand|
+              subcommand.extend Subcommand
+              subcommand.command_parent command_parent
+            end
+          end
+
+          def engine
+            @engine ||= Engine.new(owning_command: self)
+          end
+
+          class Engine
+            include CommandHelp
+
+            attr_reader :owning_command
+
+            def initialize(owning_command:)
+              @owning_command = owning_command
+            end
+
+            def command_add(command:, desc:, long_desc: nil, options: {}, commands: [])
+              self.commands[command_namespace] ||= {}
+              self.commands[command_namespace][command] = {
+                desc: desc,
+                long_desc: long_desc,
+                options: options,
+                commands: commands,
+                help: command_help_for(command: command, desc: desc,
+                  long_desc: long_desc, options: options, commands: commands)
+              }
+            end
+
+            def command_subcommand_add(subcommand, command_parent: nil)
+              command_parent ||= @owning_command
+              subcommand = subcommand.command_subcommand_create command_parent: command_parent
+              commands[command_namespace] ||= {}
+              binding.pry
+              subcommand.command_namespaces.each_with_index do |namespace, index|
+                next if index.zero?
+
+                target = commands.dig(*subcommand.command_namespaces[1..index])
+                target ||= commands.dig(*subcommand.command_namespaces[0..index - 1])
+                target[namespace] ||= {}
+              end
+              commands.dig(*subcommand.command_namespaces[0..])[subcommand.command_namespaces.last] = subcommand
+
+              # subcommand.commands.each do |command_namespace, command|
+              #   command.each do |subcommand_command, data|
+              #     commands[self.command_namespace][command_namespace] ||= {}
+              #     commands[self.command_namespace][command_namespace][subcommand_command] = {
+              #       desc: data[:desc],
+              #       long_desc: data[:long_desc],
+              #       options: data[:options],
+              #       commands: data[:commands],
+              #       help: command_help_for(command: subcommand_command, namespaces: subcommand.command_namespaces, desc: data[:desc],
+              #         long_desc: data[:long_desc], options: data[:options], commands: data[:commands])
+              #     }
+              #   end
+              # end
+            end
+
+            def command_namespaces(namespaces = [])
+              command_parent&.command_namespaces(namespaces)
+
+              namespaces << command_namespace
+              namespaces
+            end
+
+            def command_namespace(namespace = nil)
+              return @command_namespace || name if namespace.nil?
+
+              @command_namespace = namespace
+            end
+
+            def command_prompt(value = nil)
+              return @command_prompt || name if value.nil?
+
+              @command_prompt = value
+            end
+
+            def command_parent(parent = nil)
+              return @command_parent if parent.nil?
+
+              @command_parent = parent
+            end
+
+            def commands
+              @commands ||= {}
+            end
+
+            def help
+              commands.each do |_command, command_data|
+                puts "#{command_namespaces.join(' ')} #{command_data[:help]}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dsu/support/commander/command_help.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module Commander
+      module CommandHelp
+        private
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def command_help_for(command:, desc:, namespaces: nil, long_desc: nil, options: {}, commands: [])
+          namespaces ||= command_namespaces
+          help =
+            <<~HELP
+              #{namespaces&.join(' ')} #{command}#{' [OPTIONS]' if options&.any?} - #{desc}
+              #{'OPTIONS:' if options&.any?}
+              #{options_help_for options}
+              #{'OPTION ALIASES:' if any_option_aliases_for?(options)}
+              #{options_aliases_help_for options}
+              #{'---' unless long_desc.blank?}
+              #{long_desc}
+            HELP
+          help.gsub(/\n{2,}/, "\n")
+        end
+        # rubocop:enable Lint/UnusedMethodArgument
+
+        def options_help_for(options)
+          return [] if options.blank?
+
+          options.map do |option, data|
+            type = option_to_a(data[:type])&.join(' | ')
+            type = :boolean if type.blank?
+            "#{option} <#{type}>, default: #{data[:default]}"
+          end.join("\n")
+        end
+
+        def options_aliases_help_for(options)
+          return unless any_option_aliases_for?(options)
+
+          options.filter_map do |option, data|
+            aliases = option_to_a(data[:aliases])&.join(' | ')
+            <<~HELP
+              #{option} aliases: [#{aliases}]
+            HELP
+          end.join("\n")
+        end
+
+        def any_option_aliases_for?(options)
+          return false if options.blank?
+
+          options.keys.any? { |key| options.dig(key, :aliases).any? }
+        end
+
+        def option_to_a(option)
+          return [] if option.blank?
+          return option if option.is_a? Array
+
+          [option]
+        end
+      end
+    end
+  end
+end

data/lib/dsu/support/commander/subcommand.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module Commander
+      # Subcommands should extend this module once they are instantiated
+      # so that the Subcommand instance has access to all necessary
+      # class methods for this subcommand to work.
+      module Subcommand
+        class << self
+          def extended(mod)
+            mod.singleton_class.delegate :command_namespace, :commands,
+              :command_add, :command_subcommand_add, :command_prompt, :help, to: mod.class
+          end
+        end
+
+        # Subcommand-specific instance methods.
+        #
+        # Define Subcommand-specific method equivalents of the Command class
+        # methods needed to make this Subcommand instance unique.
+
+        # def command_namespace(namespace = nil)
+        #   return @command_namespace || name if namespace.nil?
+
+        #   @command_namespace = namespace
+        # end
+
+        # Subcommands can be used by any Command, so the :command_parent needs
+        # to be unique to this Subcommand instance.
+        def command_parent(parent = nil)
+          return @command_prompt if parent.nil?
+
+          @command_prompt = parent
+        end
+
+        def command_namespaces(namespaces = [])
+          command_parent&.command_namespaces(namespaces)
+
+          namespaces << command_namespace
+          namespaces
+        end
+      end
+    end
+  end
+end

data/lib/dsu/support/configuration.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'fileutils'
+require 'yaml'
+require_relative 'colorable'
+require_relative 'folder_locations'
+require_relative 'say'
+
+module Dsu
+  module Support
+    module Configuration
+      include Colorable
+      include FolderLocations
+      include Say
+
+      CONFIG_FILENAME = '.dsu'
+
+      # rubocop:disable Style/StringHashKeys - YAML writing/loading necessitates this
+      DEFAULT_DSU_OPTIONS = {
+        # 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",
+      }.freeze
+      # rubocop:enable Style/StringHashKeys
+
+      def config_file
+        File.join(root_folder, CONFIG_FILENAME)
+      end
+
+      def config_file?
+        File.exist? config_file
+      end
+
+      def create_config_file!
+        create_config_file config_file: config_file
+        print_config_file
+      end
+
+      def delete_config_file!
+        delete_config_file config_file: config_file
+      end
+
+      def print_config_file
+        if config_file?
+          say "Config file (#{config_file}) contents:", SUCCESS
+          hash = YAML.safe_load(File.open(config_file))
+          say hash.to_yaml.gsub("\n-", "\n\n-"), SUCCESS
+        else
+          say "Config file (#{config_file}) does not exist.", WARNING
+        end
+      end
+
+      private
+
+      def create_config_file(config_file:)
+        folder = File.dirname(config_file)
+        unless Dir.exist?(folder)
+          say "Destination folder for configuration file (#{folder}) does not exist", ERROR
+          return false
+        end
+
+        if File.exist?(config_file)
+          say "Configuration file (#{config_file}) already exists", WARNING
+          return false
+        end
+
+        File.write(config_file, DEFAULT_DSU_OPTIONS.to_yaml)
+        say "Configuration file (#{config_file}) created.", SUCCESS
+
+        true
+      end
+
+      def delete_config_file(config_file:)
+        unless File.exist?(config_file)
+          say "Configuration file (#{config_file}) does not exist", WARNING
+          return false
+        end
+
+        File.delete config_file
+        say "Configuration file (#{config_file}) deleted", SUCCESS
+
+        true
+      end
+    end
+  end
+end

data/lib/dsu/support/entry_group_fileable.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../services/configuration_loader_service'
+
+module Dsu
+  module Support
+    module EntryGroupFileable
+      module_function
+
+      def entry_group_file_exists?
+        File.exist?(entry_group_file_path)
+      end
+
+      def entry_group_path_exists?
+        Dir.exist?(entries_folder)
+      end
+
+      def entry_group_file_path
+        File.join(entries_folder, entries_file_name)
+      end
+
+      def entries_folder
+        @entries_folder ||= configuration[:entries_folder]
+      end
+
+      def entries_file_name
+        @entries_file_name ||= time.strftime(configuration[:entries_file_name])
+      end
+
+      def create_entry_group_path_if!
+        FileUtils.mkdir_p(entries_folder) unless entry_group_path_exists?
+      end
+
+      private
+
+      def configuration
+        @configuration ||= options[:configuration] || Services::ConfigurationLoaderService.new.call
+      end
+    end
+  end
+end

data/lib/dsu/support/entry_group_loadable.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative '../services/entry_group_reader_service'
+require_relative '../models/entry'
+
+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:)
+        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[:time] = Time.parse(hash[:time])
+          end
+        end
+
+        {
+          time: time,
+          entries: []
+        }
+      end
+
+      private
+
+      # Accepts an entry group hash and returns a
+      # hydrated entry group hash:
+      #
+      # {
+      #   time: <Time object>,
+      #   entries [
+      #     <Entry object 0>,
+      #     <Entry object 1>,
+      #     ...
+      #   ]
+      # }
+      def hydrate_entry_group_hash(entry_group_hash:, time:)
+        time = entry_group_hash.fetch(:time, time)
+        time = Time.parse(time) unless time.is_a? Time
+        entries = entry_group_hash.fetch(:entries, [])
+        entries = entries.map { |entry_hash| Models::Entry.new(**entry_hash) }
+
+        { time: time, entries: entries }
+      end
+    end
+  end
+end

data/lib/dsu/support/field_errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Dsu
+  module Support
+    module FieldErrors
+      FIELD_FORMAT_ERROR = :field_format_error
+      FIELD_TYPE_ERROR = :field_type_error
+      FIELD_DUPLICATE_ERROR = :field_duplicate_error
+    end
+  end
+end

data/lib/dsu/support/folder_locations.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'colorize'
+require 'pathname'
+
+module Dsu
+  module Support
+    module FolderLocations
+      module_function
+
+      def root_folder
+        Dir.home
+      end
+
+      def temp_folder
+        Dir.tmpdir
+      end
+    end
+  end
+end

data/lib/dsu/support/interactive/cli.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative '../ask'
+require_relative '../colorable'
+require_relative '../say'
+
+module Dsu
+  module Interactive
+    class Cli
+      include Support::Colorable
+      include Support::Ask
+      include Support::Say
+
+      BACK_COMMANDS = %w[b].freeze
+      EXIT_COMMANDS = %w[x].freeze
+      HELP_COMMANDS = %w[?].freeze
+      PROMPT_TOKEN = '>'
+
+      attr_reader :name, :parent, :prompt
+
+      def initialize(name:, parent: nil, **options)
+        @name = name
+        @parent = parent
+        @prompt = options[:prompt]
+      end
+
+      # Starts our interactive loop.
+      def start
+        help
+        process_commands
+      end
+
+      def process(command:)
+        if command.cancelled?
+          nil
+        elsif help?(command.command)
+          help
+        elsif back_or_exit?(command.command)
+          parent&.help
+        else
+          unrecognized_command command.command
+        end
+      end
+
+      # Dispays the full help; header and body.
+      def help
+        help_header
+        help_body
+      end
+
+      private
+
+      # This is our interaction loop. Commands that are NOT help or
+      # back or exit commands are yielded to the subclass to execute. Help
+      # commands simply display help; back (or exit) commands transfer control
+      # back to the parent cli (if parent? is true) or exits the current
+      # cli (if parent? is false) respectfully.
+      def process_commands
+        loop do
+          command = wrap_command(ask)
+          process(command: command)
+          next if command.cancelled?
+          break if back_or_exit?(command.command)
+        end
+        say 'Done.', ABORTED unless parent?
+      end
+
+      def wrap_command(command)
+        Struct.new(:command, :args, :cancelled, keyword_init: true) do
+          def cancelled?
+            cancelled
+          end
+
+          def cancelled!
+            self[:cancelled] = true
+          end
+        end.new(
+          command: command.split[0],
+          args: command.split[1..],
+          cancelled: false
+        )
+      end
+
+      # This is the full prompt that needs to be displayed that includes
+      # all parent prompts, right down to the current prompt.
+      def full_prompt
+        prompts = full_prompt_build prompts: []
+        prompt_token = "#{PROMPT_TOKEN} "
+        "#{prompts.join prompt_token}#{prompt_token}"
+      end
+
+      def parent?
+        !parent.nil?
+      end
+
+      def back?(command)
+        back_commands.include? command
+      end
+
+      def back_commands
+        @back_commands ||= BACK_COMMANDS
+      end
+
+      def exit?(command)
+        exit_commands.include? command
+      end
+
+      def exit_commands
+        @exit_commands ||= EXIT_COMMANDS
+      end
+
+      def back_or_exit?(command)
+        (back_commands + exit_commands).include? command
+      end
+
+      def help?(command)
+        help_commands.include? command
+      end
+
+      # Returns what are considered to be commands associated with
+      # displaying help.
+      def help_commands
+        @help_commands ||=  HELP_COMMANDS
+      end
+
+      # Displays the help header; override this if you want to customize
+      # your own help header in your subclass.
+      def help_header
+        say "#{name} Help", HIGHLIGHT
+        say '---', HIGHLIGHT
+      end
+
+      # Override this in your subclass and call super AFTER you've
+      # displayed your subclass' help body.
+      def help_body
+        say "[#{HELP_COMMANDS.join(' | ')}] Display help", HIGHLIGHT
+        say "[#{BACK_COMMANDS.join(' | ')}] Go back", HIGHLIGHT if parent?
+        say "[#{EXIT_COMMANDS.join(' | ')}] Exit", HIGHLIGHT unless parent?
+      end
+
+      # This simply outputs our prompt and accepts user input.
+      def ask
+        super full_prompt
+      end
+
+      def unrecognized_command(command)
+        say "Unrecognized command (\"#{command}\"). Try again.", ERROR
+      end
+
+      # Builds the full prompt to be used which amounts to:
+      # <parent cli prompt> PROMPT_TOKEN <child cli 1 prompt>
+      # PROMPT_TOKEN <child 2 cli prompt> ...
+      def full_prompt_build(prompts:)
+        parent.send(:full_prompt_build, prompts: prompts) if parent?
+
+        prompts << prompt
+        prompts.flatten
+      end
+    end
+  end
+end

data/lib/dsu/support/say.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'colorized_string'
+
+module Dsu
+  module Support
+    module Say
+      class << self
+        def say(text, color = nil)
+          puts say_string_for(text, color)
+        end
+
+        def say_string_for(text, color = nil)
+          unless color.nil? || color.is_a?(Symbol)
+            raise ':color is the wrong type. "Symbol" was expected, but ' \
+                  "\"#{color.class}\" was returned."
+          end
+
+          return text if color.nil?
+
+          text.public_send(color)
+        end
+      end
+
+      def say(text, color = nil)
+        Say.say(text, color)
+      end
+
+      # NOTE: some modes (ColorizedString.modes) will cancel out each other if
+      # overriden in a block. For example, if you set a string to be bold
+      # (i.e. mode: :bold) and then override it in a block (e.g. string.underline)
+      # the string will not be bold and underlined, it will just be underlined.
+      def colorize_string(string:, color: :default, mode: :default)
+        colorized_string = ColorizedString[string].colorize(color: color, mode: mode)
+        colorized_string = yield colorized_string if block_given?
+        colorized_string
+      end
+    end
+  end
+end

data/lib/dsu/support/time_formatable.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'active_support/core_ext/numeric/time'
+
+module Dsu
+  module Support
+    # This module provides functions for formatting Time objects
+    # to display in the console.
+    module TimeFormatable
+      module_function
+
+      def formatted_time(time:)
+        time = time.localtime if time.utc?
+
+        today_yesterday_or_tomorrow = if today?(time: time)
+          'Today'
+        elsif yesterday?(time: time)
+          'Yesterday'
+        elsif tomorrow?(time: time)
+          'Tomorrow'
+        end
+
+        return time.strftime('%A, %Y-%m-%d') unless today_yesterday_or_tomorrow
+
+        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
+
+      def yesterday?(time:)
+        time.strftime('%Y%m%d') == 1.day.ago(Time.now).strftime('%Y%m%d')
+      end
+
+      def tomorrow?(time:)
+        time.strftime('%Y%m%d') == 1.day.from_now(Time.now).strftime('%Y%m%d')
+      end
+    end
+  end
+end