doto 0.0.1.pre.alpha.1

data/lib/doto/support/command_hookable.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../env'
+require_relative '../models/color_theme'
+require_relative '../models/project'
+require_relative '../services/stderr_redirector_service'
+require_relative '../views/shared/error'
+require_relative 'color_themable'
+
+module Doto
+  module Support
+    module CommandHookable
+      class << self
+        def included(base)
+          base.extend(ColorThemable)
+          base.extend(ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        def start(args = ARGV, options = {})
+          display_doto_header unless suspend_header?(args, options)
+          stderror = Services::StderrRedirectorService.call do
+            super
+          end
+          display_errors_if(stderror)
+          display_doto_footer
+        end
+
+        def display_doto_header
+          if Doto.env.screen_shot_mode?
+            puts apply_theme('Running screen shot mode!', theme_color: color_theme.warning)
+            puts "#{Doto.env.screen_shot_prompt} doto #{ARGV.join(' ')}"
+          end
+        end
+
+        def display_doto_footer
+          puts apply_theme('_' * 50, theme_color: color_theme.doto_footer)
+          # TODO: I18n.
+          puts apply_theme("doto v#{Doto::VERSION} | Project: #{project} | Theme: #{color_theme.theme_name}",
+            theme_color: color_theme.doto_footer)
+        end
+
+        private
+
+        def project
+          Models::Project.current_project_name
+        end
+
+        def suspend_header?(args, _options)
+          return false unless args.count > 1
+
+          # TODO: I18n?
+          true if args[0] == 'theme' && %w[use delete].include?(args[1])
+        end
+
+        def display_errors_if(stderror_string)
+          stderror_string = stderror_string.strip
+          return unless stderror_string.present?
+
+          errors = stderror_string.split("\n").map(&:strip)
+          Views::Shared::Error.new(messages: errors, options: options.merge({ ordered_list: false })).render
+        end
+
+        def color_theme
+          Models::ColorTheme.current_or_default
+        end
+      end
+    end
+  end
+end

data/lib/doto/support/command_options/doto_times.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'time'
+require_relative 'time_mnemonic'
+
+module Doto
+  module Support
+    module CommandOptions
+      module DotoTimes
+        module_function
+
+        # Returns an array of Time objects. The first element is the "from" time.
+        # The second element is the "to" time. Both arguments are expected to be
+        # command options that are time strings, time or relative time mnemonics.
+        def doto_times_for(from_option:, to_option:)
+          from_time = doto_from_time_for(from_option: from_option)
+          to_time = doto_to_time_for(to_option: to_option, from_time: from_time)
+
+          errors = []
+          errors << I18n.t('errors.from_option_invalid', from_option: from_option) if from_time.nil?
+          errors << I18n.t('errors.to_option_invalid', to_option: to_option) if to_time.nil?
+          return [[], errors] if errors.any?
+
+          min_time, max_time = [from_time, to_time].minmax
+          [(min_time.to_date..max_time.to_date).map(&:to_time), []]
+        end
+
+        def doto_from_time_for(from_option:)
+          return if from_option.nil?
+
+          from_time = if TimeMnemonic.time_mnemonic?(from_option)
+            TimeMnemonic.time_from_mnemonic(command_option: from_option)
+          end
+          from_time || Time.time_from_date_string(command_option: from_option)
+        end
+
+        def doto_to_time_for(to_option:, from_time:)
+          to_time = if TimeMnemonic.relative_time_mnemonic?(to_option)
+            TimeMnemonic.time_from_mnemonic(command_option: to_option, relative_time: from_time)
+          elsif TimeMnemonic.time_mnemonic?(to_option)
+            TimeMnemonic.time_from_mnemonic(command_option: to_option)
+          end
+          to_time || Time.time_from_date_string(command_option: to_option)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Doto
+  module Support
+    module CommandOptions
+      # TODO: Make this into an ActiveModel class that uses validations.
+      #
+      # 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}
+
+        module_function
+
+        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_class_methods go here.
+
+        # 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)
+          # TODO: I18n.
+          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
+
+        private_class_method :time_parts_for, :time_parts?, :valid_time!, :time_string_for
+      end
+    end
+  end
+end

data/lib/doto/support/command_options/time_mnemonic.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative 'time_mnemonics'
+
+module Doto
+  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 TimeMnemonic
+        include TimeMnemonics
+
+        module_function
+
+        def time_from_mnemonic(command_option:, relative_time: nil)
+          time_from_mnemonic!(command_option: command_option, relative_time: relative_time)
+        rescue ArgumentError
+          nil
+        end
+
+        # command_option: is expected to me a time mnemonic. If relative_time is NOT nil, all
+        # time mnemonics 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 mnemonic. Otherwise, it is optional.
+        def time_from_mnemonic!(command_option:, relative_time: nil)
+          validate_argument!(command_option: command_option, command_option_name: :command_option)
+          unless relative_time.nil? || relative_time.is_a?(::Time)
+            raise ArgumentError, "relative_time is not a Time object: \"#{relative_time}\""
+          end
+
+          relative_time ||= ::Time.now
+
+          time_for_mnemonic(mnemonic: command_option, relative_time: relative_time)
+        end
+
+        # This method returns true if mnemonic is a valid mnemonic OR
+        # a relative time mnemonic.
+        def time_mnemonic?(mnemonic)
+          mnemonic?(mnemonic) || relative_time_mnemonic?(mnemonic)
+        end
+
+        # This method returns true if mnemonic is a valid relative
+        # time mnemonic.
+        def relative_time_mnemonic?(mnemonic)
+          return false unless mnemonic.is_a?(String)
+
+          mnemonic.match?(RELATIVE_REGEX)
+        end
+
+        # Add private_class_methods here.
+
+        # Returns a Time object from a mnemonic.
+        def time_for_mnemonic(mnemonic:, relative_time:)
+          time = relative_time
+          if today_mnemonic?(mnemonic)
+            time
+          elsif tomorrow_mnemonic?(mnemonic)
+            time.tomorrow
+          elsif yesterday_mnemonic?(mnemonic)
+            time.yesterday
+          elsif relative_time_mnemonic?(mnemonic)
+            relative_time_for(days_from_now: mnemonic, 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 mnemonic is a valid time mnemonic.
+        # This method will return false if mnemonic is an invalid mnemonic
+        # OR if mnemonic is a relative time mnemonic.
+        def mnemonic?(mnemonic)
+          today_mnemonic?(mnemonic) ||
+            tomorrow_mnemonic?(mnemonic) ||
+            yesterday_mnemonic?(mnemonic)
+        end
+
+        def today_mnemonic?(mnemonic)
+          TODAY.include?(mnemonic)
+        end
+
+        def tomorrow_mnemonic?(mnemonic)
+          TOMORROW.include?(mnemonic)
+        end
+
+        def yesterday_mnemonic?(mnemonic)
+          YESTERDAY.include?(mnemonic)
+        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_mnemonic?(command_option)
+            raise ArgumentError, "#{command_option_name} is an invalid mnemonic: \"#{command_option}\"."
+          end
+        end
+
+        private_class_method :time_for_mnemonic, :relative_time_for,
+          :mnemonic?, :today_mnemonic?, :tomorrow_mnemonic?,
+          :yesterday_mnemonic?, :validate_argument!
+      end
+    end
+  end
+end

data/lib/doto/support/command_options/time_mnemonics.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Doto
+  module Support
+    module CommandOptions
+      module TimeMnemonics
+        # TODO: I18n.
+        TODAY = %w[n today].freeze
+        TOMORROW = %w[t tomorrow].freeze
+        YESTERDAY = %w[y yesterday].freeze
+
+        RELATIVE_REGEX = /\A[+-]\d+\z/
+      end
+    end
+  end
+end

data/lib/doto/support/descriptable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'short_string'
+
+module Doto
+  module Support
+    module Descriptable
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+        end
+      end
+
+      def short_description
+        return '' if description.blank?
+
+        self.class.short_description(string: description)
+      end
+
+      module ClassMethods
+        include ShortString
+
+        def short_description(string:, count: ShortString::SHORT_STRING_MAX_COUNT, elipsis: '...')
+          short_string(string: string, count: count, elipsis: elipsis)
+        end
+      end
+    end
+  end
+end

data/lib/doto/support/entry_group_browsable.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative '../models/configuration'
+require_relative '../presenters/entry_group/list/dates_presenter'
+require_relative '../services/entry_group/browse_service'
+require_relative '../services/entry_group/counter_service'
+require_relative '../views/entry_group/list'
+
+module Doto
+  module Support
+    module EntryGroupBrowsable
+      def browse_entry_groups(time:, options: {})
+        raise ArgumentError, 'time must be a Time object' unless time.is_a?(Time)
+        raise ArgumentError, 'options must be a Hash' unless options.is_a?(Hash)
+
+        options = configuration.to_h.merge(options).with_indifferent_access
+        times = browse_service(time: time, options: options).call
+        if times.empty? || (options.fetch(:include_all, false) && no_entries_for?(times: times, options: options))
+          display_no_entries_to_display_message time: time, options: options
+          return
+        end
+
+        output = Services::StdoutRedirectorService.call do
+          self.class.display_doto_header
+          header = browse_header_for(time: time, options: options)
+          Views::Shared::Info.new(messages: header).render
+          puts
+          presenter = Presenters::EntryGroup::List::DatesPresenter.new(times: times, options: options)
+          Views::EntryGroup::List.new(presenter: presenter).render
+          self.class.display_doto_footer
+        end
+        output_with_pager output: output, options: options
+      end
+
+      private
+
+      def no_entries_for?(times:, options:)
+        Services::EntryGroup::CounterService.new(times: times, options: options).call.zero?
+      end
+
+      def browse_header_for(time:, options:)
+        of, times = case options[:browse]
+        when :week
+          [
+            I18n.t('subcommands.browse.headers.week_of', week: time.beginning_of_week.to_date),
+            [time.beginning_of_week, time.end_of_week]
+          ]
+        when :month
+          [
+            I18n.t('subcommands.browse.headers.month_of', month: I18n.l(time, format: '%B')),
+            [time.beginning_of_month, time.end_of_month]
+          ]
+        when :year
+          [
+            I18n.t('subcommands.browse.headers.year_of', year: time.to_date.year),
+            [time.beginning_of_year, time.end_of_year]
+          ]
+        end
+
+        I18n.t('subcommands.browse.headers.browsing', of: of, from: times.min.to_date.to_s, to: times.max.to_date.to_s)
+      end
+
+      def output_with_pager(output:, options:)
+        if options[:pager] == false
+          puts output
+          return
+        end
+
+        pager_command = if RUBY_PLATFORM.match?(/win32|windows/i)
+          'more' # Windows command
+        else
+          'less' # Unix-like command
+        end
+
+        IO.popen(pager_command, 'w') do |pipe|
+          pipe.puts output
+          pipe.close_write
+        end
+      rescue Errno::ENOENT
+        message = "Operating system pager command (#{pager_command}) not found. Falling back to direct output."
+        Views::Shared::Error.new(messages: message).render
+        puts output
+      end
+
+      def display_no_entries_to_display_message(time:, options:)
+        case options[:browse]
+        when :week
+          Views::EntryGroup::Shared::NoEntriesToDisplayForWeekOf.new(time: time, options: options).render
+        when :month
+          Views::EntryGroup::Shared::NoEntriesToDisplayForMonthOf.new(time: time, options: options).render
+        when :year
+          Views::EntryGroup::Shared::NoEntriesToDisplayForYearOf.new(time: time, options: options).render
+        else
+          raise NotImplementedError, 'Unhandled option; ' \
+                                     "expected :week, :month, or :year but received #{options[:browse]}"
+        end
+      end
+
+      def browse_service(time:, options: {})
+        Services::EntryGroup::BrowseService.new(time: time, options: options)
+      end
+    end
+  end
+end

data/lib/doto/support/field_errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Doto
+  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/doto/support/fileable.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Doto
+  module Support
+    module Fileable
+      MIGRATION_VERSION_FILE_NAME = 'migration_version.json'
+
+      def doto_folder
+        File.join(root_folder, 'doto')
+      end
+
+      # Configuration
+
+      def config_folder
+        root_folder
+      end
+
+      def config_file_name
+        '.doto'
+      end
+
+      def config_path
+        File.join(config_folder, config_file_name)
+      end
+
+      # Entries
+
+      def entries_folder
+        project_folder = project_folder_for(project_name: Models::Project.current_project_name)
+        File.join(project_folder, 'entries')
+      end
+
+      def entries_file_name(time:, file_name_format: nil)
+        file_name_format ||= '%Y-%m-%d.json'
+        time.strftime(file_name_format)
+      end
+
+      def entries_path(time:, file_name_format: nil)
+        File.join(entries_folder, entries_file_name(time: time, file_name_format: file_name_format))
+      end
+
+      # Themes
+
+      def themes_folder
+        File.join(doto_folder, 'themes')
+      end
+
+      def themes_path(theme_name:)
+        File.join(themes_folder, theme_file_name(theme_name: theme_name))
+      end
+
+      def theme_file_name(theme_name:)
+        "#{theme_name}.json"
+      end
+
+      # Migration
+
+      def migration_version_folder
+        File.join(doto_folder)
+      end
+
+      def migration_version_path
+        File.join(migration_version_folder, MIGRATION_VERSION_FILE_NAME)
+      end
+
+      # Base folders
+
+      def root_folder
+        Dir.home
+      end
+
+      def temp_folder
+        Dir.tmpdir
+      end
+
+      def gem_dir
+        Gem.loaded_specs['doto'].gem_dir
+      end
+
+      # Seed data files and folders
+
+      def seed_data_doto_folder_for(migration_version:)
+        File.join(gem_dir, 'lib/seed_data', migration_version.to_s, 'doto')
+      end
+
+      def seed_data_doto_configuration_for(migration_version:)
+        File.join(gem_dir, 'lib/seed_data', migration_version.to_s, '.doto')
+      end
+
+      # Projects
+
+      # Returns the folder where all the projects are stored.
+      def projects_folder
+        File.join(doto_folder, 'projects')
+      end
+
+      # Current project
+
+      # Contains the name of the file that contains the current
+      # doto project currently being used.
+      def current_project_file_name
+        'current_project.json'
+      end
+
+      # The complete path to the current project file.
+      def current_project_file
+        File.join(doto_folder, current_project_file_name)
+      end
+
+      # Project helpers
+
+      # Returns the path of the project with the given name.
+      def project_folder_for(project_name:)
+        raise I18n.t('errors.project_name_invalid', project_name: '{{blank}}') if project_name.blank?
+
+        File.join(projects_folder, project_name)
+      end
+      alias project_folder project_folder_for
+
+      def project_file_for(project_name:)
+        project_folder = project_folder_for(project_name: project_name)
+
+        File.join(project_folder, 'project.json')
+      end
+      alias project_file project_file_for
+
+      # Backup folders
+
+      def backup_folder_for(migration_version:)
+        File.join(root_folder, "doto-#{migration_version}-backup")
+      end
+
+      extend self # rubocop:disable Style/ModuleFunction
+    end
+  end
+end

data/lib/doto/support/presentable.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Doto
+  module Support
+    module Presentable
+      def presenter
+        "Doto::Presenters::#{self.class.name.demodulize}Presenter".constantize.new(self, options: options)
+      end
+    end
+  end
+end