dsu 1.2.1 → 2.0.1

data/lib/dsu/services/configuration_loader_service.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'erb'
-require 'yaml'
-require_relative '../support/configuration'
-
-module Dsu
-  module Services
-    # This class loads an entry group file.
-    class ConfigurationLoaderService
-      include Dsu::Support::Configuration
-
-      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
-        config_options.merge(default_options).with_indifferent_access
-      end
-
-      private
-
-      attr_reader :default_options
-
-      def config_options
-        return default_config unless config_file?
-
-        @config_options ||= begin
-          loaded_config = YAML.safe_load(ERB.new(File.read(config_file)).result)
-          loaded_config = update_and_write_config_file!(loaded_config) unless loaded_config.keys == default_config.keys
-          loaded_config
-        end
-      end
-
-      def update_and_write_config_file!(loaded_config)
-        loaded_config = default_config.merge(loaded_config)
-        # TODO: Make this into a configuration writer service.
-        # TODO: Test this
-        File.write(config_file, loaded_config.to_yaml)
-        loaded_config
-      end
-
-      def default_config
-        Support::Configuration::DEFAULT_DSU_OPTIONS
-      end
-    end
-  end
-end

data/lib/dsu/services/entry_group_deleter_service.rb

@@ -1,31 +0,0 @@
-# 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_editor_service.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../models/entry'
-require_relative '../support/colorable'
-require_relative '../support/configurable'
-require_relative '../support/say'
-require_relative '../support/time_formatable'
-require_relative '../views/edited_entries/shared/errors'
-require_relative '../views/shared/messages'
-require_relative 'stdout_redirector_service'
-
-module Dsu
-  module Services
-    class EntryGroupEditorService
-      include Support::Colorable
-      include Support::Configurable
-      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
-    end
-  end
-end

data/lib/dsu/services/entry_group_hydrator_service.rb

@@ -1,43 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# 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!
-        entry_group
-      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

@@ -1,35 +0,0 @@
-# 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/services/temp_file_reader_service.rb

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

data/lib/dsu/services/temp_file_writer_service.rb

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

data/lib/dsu/support/colorable.rb

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

data/lib/dsu/support/configurable.rb

@@ -1,15 +0,0 @@
-# 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

@@ -1,112 +0,0 @@
-# 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 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",
-        '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
-
-      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
-
-      # 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
-          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
-          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
-
-      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

@@ -1,49 +0,0 @@
-# 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
-      include Support::Configurable
-
-      def entry_group_file_exists?
-        File.exist?(entry_group_file_path)
-      end
-
-      def entry_group_file_exists_for?(time:)
-        entries_file_name = time.strftime(configuration_or_options_configuration[:entries_file_name])
-        File.join(entries_folder, entries_file_name)
-      end
-
-      private
-
-      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_or_options_configuration[:entries_folder]
-      end
-
-      def entries_file_name
-        @entries_file_name ||= time.strftime(configuration_or_options_configuration[:entries_file_name])
-      end
-
-      def create_entry_group_path_if!
-        FileUtils.mkdir_p(entries_folder) unless entry_group_path_exists?
-      end
-
-      def configuration_or_options_configuration
-        @configuration_or_options_configuration ||= options[:configuration] || configuration
-      end
-    end
-  end
-end

data/lib/dsu/support/entry_group_loadable.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-require_relative '../services/entry_group_reader_service'
-require_relative '../models/entry'
-require_relative '../models/entry_group'
-
-module Dsu
-  module Support
-    module EntryGroupLoadable
-      # returns an EntryGroup object loaded from
-      # the entry group json file.
-      def load(time:)
-        entry_group_json = Services::EntryGroupReaderService.new(time: time).call
-        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
-
-        Models::EntryGroup.new(**hydrate_entry_group_hash(hash: hash, time: time))
-      end
-
-      module_function
-
-      # 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(hash:, time:)
-        time = hash.fetch(:time, time)
-        time = Time.parse(time) unless time.is_a? Time
-        entries = 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/folder_locations.rb

@@ -1,21 +0,0 @@
-# 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