doto 0.0.1.pre.alpha.1

data/lib/doto/presenters/project/use_by_number_presenter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../../models/project'
+require_relative '../base_presenter_ex'
+require_relative 'defaultable'
+
+module Doto
+  module Presenters
+    module Project
+      class UseByNumberPresenter < BasePresenterEx
+        include Defaultable
+
+        attr_reader :project_number
+
+        delegate :project_name, to: :project, allow_nil: true
+        delegate :description, to: :project, prefix: true, allow_nil: true
+
+        def initialize(project_number:, options: {})
+          super(options: options)
+
+          raise ArgumentError, 'project_number is blank' if project_number.blank?
+
+          self.project_number = project_number
+        end
+
+        def respond(response:)
+          return false unless response
+
+          project.default! if make_default? && project&.present?
+          project.use! if project&.present?
+        end
+
+        def already_current_project?
+          project&.current_project?
+        end
+
+        def project_does_not_exist?
+          !project&.exist?
+        end
+
+        def project_errors
+          return false unless project&.persisted?
+
+          project.errors.full_messages
+        end
+
+        private
+
+        attr_writer :project_number
+
+        def project
+          @project ||= Models::Project.find_by_number(project_number: project_number)
+        end
+      end
+    end
+  end
+end

data/lib/doto/presenters/project/use_presenter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../../models/project'
+require_relative '../base_presenter_ex'
+require_relative 'defaultable'
+
+module Doto
+  module Presenters
+    module Project
+      class UsePresenter < BasePresenterEx
+        include Defaultable
+
+        attr_reader :project_name
+
+        delegate :description, to: :project, prefix: true, allow_nil: true
+
+        def initialize(project_name:, options: {})
+          super(options: options)
+
+          raise ArgumentError, 'project_name is blank' if project_name.blank?
+
+          self.project_name = project_name
+        end
+
+        def respond(response:)
+          return false unless response
+
+          project.default! if make_default? && project&.present?
+          project.use! if project&.present?
+        end
+
+        def already_current_project?
+          project&.current_project?
+        end
+
+        def project_does_not_exist?
+          !project.exist?
+        end
+
+        def project_errors
+          return false unless project.persisted?
+
+          project.errors.full_messages
+        end
+
+        private
+
+        attr_writer :project_name
+
+        def project
+          @project ||= Models::Project.find_or_initialize(project_name: project_name)
+        end
+      end
+    end
+  end
+end

data/lib/doto/services/color_theme/hydrator_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../../models/color_theme'
+
+module Doto
+  module Services
+    module ColorTheme
+      class HydratorService
+        def initialize(theme_name:, theme_hash:, options: {})
+          raise ArgumentError, 'theme_name is nil.' if theme_name.nil?
+          raise ArgumentError, "theme_name is the wrong object type: \"#{theme_name}\"." unless theme_hash.is_a?(Hash)
+          raise ArgumentError, 'theme_hash is nil' if theme_hash.nil?
+          raise ArgumentError, "theme_hash is the wrong object type: \"#{theme_hash}\"" unless theme_hash.is_a?(Hash)
+          raise ArgumentError, 'options is nil' if options.nil?
+          raise ArgumentError, "options is the wrong object type:\"#{options}\"" unless options.is_a?(Hash)
+
+          @theme_name = theme_name
+          @theme_hash = theme_hash
+          @options = options || {}
+        end
+
+        def call
+          Models::ColorTheme.new(theme_name: theme_name, theme_hash: hydrate)
+        end
+
+        private
+
+        attr_reader :theme_hash, :theme_name, :options
+
+        def hydrate
+          theme_hash.each_pair do |key, value|
+            next if %i[version description].include?(key)
+
+            value.each_pair do |k, _v|
+              value[k] = value[k].to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doto/services/configuration/hydrator_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../../models/configuration'
+require_relative '../../views/shared/message'
+
+module Doto
+  module Services
+    module Configuration
+      class HydratorService
+        def initialize(config_hash:, options: {})
+          raise ArgumentError, 'config_hash is nil' if config_hash.nil?
+
+          unless config_hash.is_a?(Hash)
+            raise ArgumentError,
+              "config_hash is the wrong object type: \"#{config_hash}\""
+          end
+          raise ArgumentError, 'options is nil' if options.nil?
+          raise ArgumentError, "options is the wrong object type:\"#{options}\"" unless options.is_a?(Hash)
+
+          @config_hash = config_hash.dup
+          @options = options || {}
+        end
+
+        def call
+          hydrate
+        end
+
+        private
+
+        attr_reader :config_hash, :options
+
+        def hydrate
+          config_hash[:version] = config_hash[:version].to_i
+          config_hash[:entries_display_order] = config_hash[:entries_display_order].to_sym
+          config_hash
+        rescue JSON::ParserError => _e
+          Models::Configuration::DEFAULT_CONFIGURATION
+        end
+      end
+    end
+  end
+end

data/lib/doto/services/entry/hydrator_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../models/entry'
+
+module Doto
+  module Services
+    module Entry
+      class HydratorService
+        def initialize(entries_array:, options: {})
+          raise ArgumentError, 'entries_array is nil' if entries_array.nil?
+          raise ArgumentError, 'options is nil' if options.nil?
+
+          @entries_array = entries_array
+          @options = options || {}
+        end
+
+        def call
+          hydrate
+        end
+
+        private
+
+        attr_reader :entries_array, :options
+
+        def hydrate
+          entries_array.map do |entry_hash|
+            Doto::Models::Entry.new(**entry_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doto/services/entry_group/browse_service.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative '../../models/entry_group'
+require_relative '../../support/time_formatable'
+require_relative '../../support/times_sortable'
+
+module Doto
+  module Services
+    module EntryGroup
+      # This service is responsible for returning an array of
+      # sorted entry group dates as Time objects. The Time objects
+      # returned, and the sort order are determined by the options
+      # passed in.
+      class BrowseService
+        include Support::TimeFormatable
+        include Support::TimesSortable
+
+        def initialize(time:, options: {})
+          raise ArgumentError, 'Argument time is nil' if time.nil?
+          raise ArgumentError, 'Argument options is nil' if options.nil?
+
+          @time = time
+          @options = options
+        end
+
+        def call
+          return [] if entry_group_times.empty?
+
+          times_sort(times: entry_group_times, entries_display_order: entries_display_order)
+        end
+
+        private
+
+        attr_reader :time, :options
+
+        def entry_group_times
+          @entry_group_times ||= (min_time.to_i..max_time.to_i).step(1.day).each_with_object([]) do |time_step, times|
+            time = Time.at(time_step)
+            next unless include_all? || entry_group_count(time).positive?
+
+            times << time
+          end
+        end
+
+        def entry_group_count(time)
+          entry_group = Models::EntryGroup.find_or_initialize(time: time)
+          entry_group.persisted? ? entry_group.entries.count : 0
+        end
+
+        def min_time
+          @min_time ||= if week?
+            time.beginning_of_week
+          elsif month?
+            time.beginning_of_month
+          elsif year?
+            time.beginning_of_year
+          end
+        end
+
+        def max_time
+          @max_time ||= if week?
+            time.end_of_week
+          elsif month?
+            time.end_of_month
+          elsif year?
+            time.end_of_year
+          end
+        end
+
+        def entries_display_order
+          options[:entries_display_order] || default_entries_display_order
+        end
+
+        def default_entries_display_order
+          :asc
+        end
+
+        def week?
+          options.fetch(:browse, default_browse) == :week
+        end
+
+        def month?
+          options[:browse] == :month
+        end
+
+        def year?
+          options[:browse] == :year
+        end
+
+        def default_browse
+          :week
+        end
+
+        def include_all?
+          options.fetch(:include_all, false)
+        end
+      end
+    end
+  end
+end

data/lib/doto/services/entry_group/counter_service.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../models/entry_group'
+
+module Doto
+  module Services
+    module EntryGroup
+      class CounterService
+        def initialize(times:, options: {})
+          raise ArgumentError, 'Argument times is nil' if times.nil?
+
+          @times = times
+          @options = options
+        end
+
+        def call
+          total_entry_groups = 0
+
+          times.each do |time|
+            total_entry_groups += 1 if Models::EntryGroup.exist?(time: time)
+          end
+
+          total_entry_groups
+        end
+
+        private
+
+        attr_reader :times, :options
+      end
+    end
+  end
+end

data/lib/doto/services/entry_group/deleter_service.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../models/entry_group'
+
+module Doto
+  module Services
+    module EntryGroup
+      class DeleterService
+        def initialize(times:, options: {})
+          raise ArgumentError, 'Argument times is nil' if times.nil?
+
+          @times = times
+          @options = options
+        end
+
+        def call
+          deleted_entry_groups = 0
+
+          times.each do |time|
+            next unless Models::EntryGroup.exist?(time: time)
+
+            Models::EntryGroup.delete(time: time)
+            deleted_entry_groups += 1
+          end
+
+          deleted_entry_groups
+        end
+
+        private
+
+        attr_reader :times, :options
+      end
+    end
+  end
+end

data/lib/doto/services/entry_group/editor_service.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative '../../models/color_theme'
+require_relative '../../models/entry'
+require_relative '../../support/color_themable'
+require_relative '../../support/time_formatable'
+require_relative '../../views/shared/model_errors'
+require_relative '../stdout_redirector_service'
+require_relative '../temp_file/reader_service'
+require_relative '../temp_file/writer_service'
+
+module Doto
+  module Services
+    module EntryGroup
+      class EditorService
+        include Support::ColorThemable
+        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
+          message = I18n.t('services.editor_service.messages.editing',
+            formatted_time: formatted_time(time: entry_group.time))
+          puts apply_theme(message, theme_color: color_theme.header)
+          # TODO: Call #render_as_string directly below?
+          StdoutRedirectorService.call { Views::EntryGroup::Edit.new(entry_group: entry_group).render }
+          # Views::EntryGroup::Edit.new(entry_group: entry_group).render_as_string
+        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)
+
+          TempFile::WriterService.new(tmp_file_content: edit_view).call do |tmp_file_path|
+            if Kernel.system("${EDITOR:-#{configuration.editor}} #{tmp_file_path}")
+              TempFile::ReaderService.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
+              message_array = I18n.t('services.editor_service.errors.temp_file_error',
+                editor: ENV.fetch('EDITOR', configuration.editor),
+                status: $CHILD_STATUS).split("\n")
+              puts apply_theme(message_array, theme_color: color_theme.error)
+            end
+          end
+        end
+
+        def process_entry_group!(entry_group_with_edits)
+          if entry_group_with_edits.entries.empty?
+            entry_group.delete
+            return
+          end
+
+          Views::Shared::ModelErrors.new(model: entry_group_with_edits).render if entry_group_with_edits.invalid?
+
+          # 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
+
+        def color_theme
+          @color_theme ||= Models::ColorTheme.current_or_default
+        end
+
+        def configuration
+          Models::Configuration.new
+        end
+      end
+    end
+  end
+end

data/lib/doto/services/entry_group/exporter_service.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'csv'
+require_relative '../../models/entry_group'
+require_relative '../../support/fileable'
+require_relative '../../support/transform_project_name'
+
+module Doto
+  module Services
+    module EntryGroup
+      # ExporterService exports entry groups to a CSV file.
+      # NOTE: This class exports all entries passed to it. It does not filter
+      # entries based on optional options[:time] that may be passed to it.
+      # Rather, times are used to determine the export file name only.
+      class ExporterService
+        include Support::Fileable
+        include Support::TransformProjectName
+
+        def initialize(project_name:, entry_groups:, options: {})
+          raise ArgumentError, 'Argument project_name is blank' if project_name.blank?
+          raise ArgumentError, 'Argument entry_groups is blank' if entry_groups.blank?
+          raise ArgumentError, 'Argument entry_groups are not all valid' unless entry_groups.all?(&:valid?)
+
+          validate_entry_group_entries_present! entry_groups
+
+          @project_name = project_name
+          @entry_groups = entry_groups
+          @options = options
+        end
+
+        def call
+          CSV.open(export_file_path, 'w') do |csv|
+            csv << %i[project_name version entry_group entry_no total_entries entry_group_entry]
+
+            entry_groups.each do |entry_group|
+              export_entry_group(entry_group: entry_group, csv: csv)
+            end
+          end
+
+          export_file_path
+        end
+
+        def export_file_path
+          @export_file_path ||= File.join(temp_folder, export_file_name)
+        end
+
+        private
+
+        attr_reader :project_name, :entry_groups, :options
+
+        def export_entry_data(entry_group:, entry:, entry_index:)
+          [
+            project_name,
+            entry_group.version,
+            entry_group.time.to_date,
+            entry_index + 1,
+            entry_group.entries.count,
+            entry.description
+          ]
+        end
+
+        def export_entry_group(entry_group:, csv:)
+          entry_group.entries.each_with_index do |entry, index|
+            csv << export_entry_data(entry_group: entry_group, entry: entry, entry_index: index)
+          end
+        end
+
+        def export_file_name
+          transformed_file_name = transform_project_name project_name, options: options
+          "doto-export-#{transformed_file_name}-" \
+            "#{timestamp}-#{export_scope}-#{times.min.to_date}-thru-#{times.max.to_date}.csv"
+        end
+
+        def export_scope
+          return 'all-entry-groups' unless options.fetch(:times, nil)
+
+          'entry-groups'
+        end
+
+        def times
+          @times ||= options.fetch(:times, entry_groups.map(&:time))
+        end
+
+        def timestamp
+          @timestamp ||= Time.now.in_time_zone.strftime('%Y%m%d%H%M%S')
+        end
+
+        def validate_entry_group_entries_present!(entry_groups)
+          entry_groups.each do |entry_group|
+            next if entry_group.entries.present?
+
+            raise ArgumentError, "Argument entry_groups entry group for #{entry_group.time_yyyy_mm_dd} has no entries"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doto/services/entry_group/hydrator_service.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../models/entry_group'
+require_relative '../entry/hydrator_service'
+
+module Doto
+  module Services
+    module EntryGroup
+      class HydratorService
+        def initialize(entry_group_hash:, options: {})
+          raise ArgumentError, 'entry_group_hash is nil' if entry_group_hash.nil?
+          raise ArgumentError, 'options is nil' if options.nil?
+
+          @entry_group_hash = entry_group_hash
+          @options = options || {}
+        end
+
+        def call
+          Models::EntryGroup.new(**hydrate)
+        end
+
+        private
+
+        attr_reader :entry_group_hash, :options
+
+        # Returns a Hash with :time and :entries values hydrated (i.e. Time and Entry objects respectively).
+        def hydrate
+          entry_group_hash.tap do |hash|
+            hash[:time] = Time.parse(hash[:time])
+            hash[:entries] =
+              Entry::HydratorService.new(entries_array: hash[:entries], options: options).call
+          end
+        end
+      end
+    end
+  end
+end