doto 0.0.1.pre.alpha.1

data/exe/doto

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'rubygems'
+
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+if File.exist?('.env.development')
+  # This loads our development environment when running dev.
+  require 'dotenv'
+  Dotenv.load('.env.development')
+end
+
+require 'doto'
+
+if Doto.env.development?
+  # This simply allows us to use a folder other than doto folder for the production
+  # release, so we don't mess with our current production doto folder.
+  module Doto
+    module Support
+      module Fileable
+        def root_folder
+          File.join(gem_dir, '.development_home')
+        end
+      end
+    end
+  end
+
+  puts "ATTENTION: Doto root folder is: #{Doto::Support::Fileable.root_folder}!"
+end
+
+Doto::CLI.start(ARGV)

data/lib/core/ruby/color_theme_colors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ColorThemeColors
+  DEFAULT_THEME_COLORS = { color: :default, mode: :default, background: :default }.freeze
+
+  # Ensures that default colors and mode are represented in the returned Hash.
+  def merge_default_colors
+    # TODO: Error checking.
+    DEFAULT_THEME_COLORS.merge(dup)
+  end
+
+  def merge_default_colors!
+    # TODO: Error checking.
+    merge!(merge_default_colors)
+  end
+end

data/lib/core/ruby/color_theme_mode.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# TODO: Error checking.
+# TODO: Keep <method>! (bang)?
+module ColorThemeMode
+  def default!
+    dup.merge({ mode: :default })
+  end
+
+  def bold!
+    dup.merge({ mode: :bold })
+  end
+
+  def italic!
+    dup.merge({ mode: :italic })
+  end
+
+  def underline!
+    dup.merge({ mode: :underline })
+  end
+
+  def blink!
+    dup.merge({ mode: :blink })
+  end
+
+  def swap!
+    dup.merge({ mode: :swap })
+  end
+
+  def hide!
+    dup.merge({ mode: :hide })
+  end
+
+  def mode!(mode)
+    dup.merge({ mode: mode })
+  end
+
+  def light!
+    light_color = :"light_#{self[:color].to_s.gsub('light_', '')}"
+    dup.merge({ color: light_color })
+  end
+end

data/lib/core/ruby/wrap_and_join.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module WrapAndJoin
+  class << self
+    def included(base)
+      base.const_set(:WRAP_AND_JOIN_JOIN_TOKEN, ', ')
+    end
+  end
+
+  def wrap_and_join(wrapper: %w["], join: Array::WRAP_AND_JOIN_JOIN_TOKEN)
+    validate_wrapper!(wrapper)
+    validate_join!(join)
+
+    wrapper << wrapper.first if wrapper.count == 1
+    map { |element| "#{wrapper[0]}#{element}#{wrapper[1]}" }.join(join)
+  end
+
+  private
+
+  def validate_wrapper!(wrapper)
+    raise ArgumentError, 'wrapper is nil' if wrapper.nil?
+    raise ArgumentError, 'wrapper must be an Array' unless wrapper.is_a?(Array)
+    raise ArgumentError, 'wrapper must be an Array of 1 or 2 wrapper elements' unless wrapper.count.between?(1, 2)
+  end
+
+  def validate_join!(join)
+    return if join.nil?
+
+    raise ArgumentError, 'join must be a String' unless join.is_a?(String)
+  end
+end

data/lib/doto/base_cli.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'bundler'
+require 'thor'
+require_relative 'command_services/add_entry_service'
+require_relative 'models/color_theme'
+require_relative 'models/configuration'
+require_relative 'models/entry_group'
+require_relative 'services/stdout_redirector_service'
+require_relative 'support/color_themable'
+require_relative 'support/command_help_colorizeable'
+require_relative 'support/command_hookable'
+require_relative 'support/times_sortable'
+require_relative 'version'
+require_relative 'views/entry_group/show'
+
+module Doto
+  class BaseCLI < ::Thor
+    include Support::ColorThemable
+    include Support::CommandHelpColorizable
+    include Support::CommandHookable
+    include Support::TimesSortable
+
+    class_option :debug, type: :boolean, default: false
+
+    default_command :help
+
+    def initialize(*args)
+      super
+
+      @configuration = Models::Configuration.new
+    end
+
+    class << self
+      def exit_on_failure?
+        false
+      end
+
+      def date_option_description
+        I18n.t('options.date_option_description')
+      end
+
+      def mnemonic_option_description
+        I18n.t('options.mnemonic_option_description')
+      end
+    end
+
+    private
+
+    attr_reader :configuration
+
+    def color_theme
+      Models::ColorTheme.current_or_default
+    end
+  end
+end

data/lib/doto/cli.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'time'
+require_relative 'base_cli'
+require_relative 'presenters/entry_group/list/date_presenter'
+require_relative 'subcommands/browse'
+require_relative 'subcommands/config'
+require_relative 'subcommands/delete'
+require_relative 'subcommands/edit'
+require_relative 'subcommands/export'
+require_relative 'subcommands/import'
+require_relative 'subcommands/list'
+require_relative 'subcommands/project'
+require_relative 'subcommands/theme'
+require_relative 'support/command_options/time_mnemonic'
+require_relative 'support/time_formatable'
+require_relative 'views/entry_group/list'
+
+module Doto
+  # The `doto` command.
+  class CLI < BaseCLI
+    include Support::CommandOptions::TimeMnemonic
+    include Support::TimeFormatable
+
+    map I18n.t('commands.add.key_mappings') => :add
+    map I18n.t('commands.browse.key_mappings') => :browse
+    map I18n.t('commands.config.key_mappings') => :config
+    map I18n.t('commands.delete.key_mappings') => :delete
+    map I18n.t('commands.edit.key_mappings') => :edit
+    map I18n.t('commands.export.key_mappings') => :export
+    map I18n.t('commands.help.key_mappings') => :help
+    map I18n.t('commands.import.key_mappings') => :import
+    map I18n.t('commands.info.key_mappings') => :info
+    map I18n.t('commands.list.key_mappings') => :list
+    map I18n.t('commands.project.key_mappings') => :project
+    map I18n.t('commands.theme.key_mappings') => :theme
+    map I18n.t('commands.version.key_mappings') => :version
+
+    desc I18n.t('commands.add.desc'), I18n.t('commands.add.usage')
+    long_desc I18n.t('commands.add.long_desc',
+      date_option_description: date_option_description, mnemonic_option_description: mnemonic_option_description)
+    option I18n.t('options.date_or_mnemonic.name'), aliases: I18n.t('options.date_or_mnemonic.aliases'),
+      type: :string, banner: I18n.t('options.date_or_mnemonic.banner')
+    option I18n.t('options.tomorrow.name'), aliases: I18n.t('options.tomorrow.aliases'), type: :boolean
+    option I18n.t('options.yesterday.name'), aliases: I18n.t('options.yesterday.aliases'), type: :boolean
+    option I18n.t('options.today.name'), aliases: I18n.t('options.today.aliases'), type: :boolean, default: true
+    def add(description)
+      date_or_mnemonic = if options[I18n.t('options.date.name')].present?
+        options[I18n.t('options.date.name')]
+      elsif options[I18n.t('options.tomorrow.name')].present?
+        I18n.t('options.tomorrow.name')
+      elsif options[I18n.t('options.yesterday.name')].present?
+        I18n.t('options.yesterday.name')
+      elsif options[I18n.t('options.today.name')].present?
+        I18n.t('options.today.name')
+      end
+      time = if time_mnemonic?(date_or_mnemonic)
+        time_from_mnemonic(command_option: date_or_mnemonic)
+      else
+        Time.parse(date_or_mnemonic)
+      end
+      entry = Models::Entry.new(description: description)
+      CommandServices::AddEntryService.new(entry: entry, time: time).call
+      presenter = Presenters::EntryGroup::List::DatePresenter.new(times: [time], options: options)
+      # TODO: Refactor View::EntryGroup::Show to accept a presenter and use it here
+      Views::EntryGroup::List.new(presenter: presenter).render
+    rescue ArgumentError => e
+      Views::Shared::Error.new(messages: e.message).render
+    end
+
+    desc I18n.t('commands.browse.desc'), I18n.t('commands.browse.usage')
+    subcommand :browse, Subcommands::Browse
+
+    desc I18n.t('commands.list.desc'), I18n.t('commands.list.usage')
+    subcommand :list, Subcommands::List
+
+    desc I18n.t('commands.project.desc'), I18n.t('commands.project.usage')
+    subcommand :project, Subcommands::Project
+
+    desc I18n.t('commands.config.desc'), I18n.t('commands.config.usage')
+    subcommand :config, Subcommands::Config
+
+    desc I18n.t('commands.delete.desc'), I18n.t('commands.delete.usage')
+    subcommand :delete, Subcommands::Delete
+
+    desc I18n.t('commands.edit.desc'), I18n.t('commands.edit.usage')
+    subcommand :edit, Subcommands::Edit
+
+    desc I18n.t('commands.export.desc'), I18n.t('commands.export.usage')
+    subcommand :export, Subcommands::Export
+
+    desc I18n.t('commands.theme.desc'), I18n.t('commands.theme.usage')
+    subcommand :theme, Subcommands::Theme
+
+    desc I18n.t('commands.import.desc'), I18n.t('commands.import.usage')
+    subcommand :import, Subcommands::Import
+
+    desc I18n.t('commands.info.desc'), I18n.t('commands.info.usage')
+    def info
+      configuration_version = Models::Configuration::VERSION
+      entry_group_version = Models::EntryGroup::VERSION
+      color_theme_version = Models::ColorTheme::VERSION
+      info = I18n.t('commands.info.info',
+        doto_version: doto_version,
+        configuration_version: configuration_version,
+        entry_group_version: entry_group_version,
+        color_theme_version: color_theme_version,
+        config_folder: Support::Fileable.config_path,
+        root_folder: Support::Fileable.root_folder,
+        entries_folder: Support::Fileable.entries_folder,
+        themes_folder: Support::Fileable.themes_folder,
+        gem_folder: Support::Fileable.gem_dir,
+        temp_folder: Support::Fileable.temp_folder,
+        migration_version_folder: Support::Fileable.migration_version_folder,
+        migration_file_folder: Support::Fileable.migration_version_path)
+      puts apply_theme(info, theme_color: color_theme.body)
+    end
+
+    desc I18n.t('commands.version.desc'), I18n.t('commands.version.usage')
+    def version
+      puts apply_theme(doto_version, theme_color: color_theme.body)
+    end
+
+    private
+
+    def doto_version
+      "v#{VERSION}"
+    end
+  end
+end

data/lib/doto/command_services/add_entry_service.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../models/entry'
+require_relative '../support/color_themable'
+require_relative '../support/descriptable'
+require_relative '../support/fileable'
+require_relative '../views/shared/error'
+
+module Doto
+  module CommandServices
+    # This class adds (does NOT update) an entry to an entry group by
+    # writing it to the appropriate entry group json file.
+    class AddEntryService
+      include Support::ColorThemable
+      include Support::Descriptable
+      include Support::Fileable
+
+      attr_reader :entry, :entry_group, :time
+
+      delegate :description, to: :entry
+
+      # :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?(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 = Models::EntryGroup.find_or_initialize(time: time)
+      end
+
+      def call
+        entry.validate!
+        entry_group.entries << entry
+        entry_group.save!
+        entry
+      rescue ActiveModel::ValidationError => e
+        header = I18n.t('headers.entry.could_not_be_added')
+        Views::Shared::Error.new(messages: e.message, header: header).render
+      end
+
+      private
+
+      attr_writer :entry, :entry_group, :time
+    end
+  end
+end

data/lib/doto/crud/json_file.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'json'
+require_relative '../migration/version'
+
+module Doto
+  module Crud
+    class JsonFile
+      include ActiveModel::Model
+
+      attr_reader :file_path
+
+      def initialize(file_path)
+        @file_path = file_path
+      end
+
+      def update_version!
+        @version = Migration::VERSION
+      end
+
+      def delete
+        self.class.delete(file_path: file_path)
+      end
+
+      def delete!
+        self.class.delete!(file_path: file_path)
+      end
+
+      def file_exist?
+        self.class.file_exist?(file_path: file_path)
+      end
+
+      def persisted?
+        file_exist?
+      end
+
+      # Override this method to reload data from the file
+      def reload
+        @version = read_version
+
+        self
+      end
+
+      def to_h
+        raise NotImplementedError, 'You must implement this method in a your subclass'
+      end
+
+      def to_model
+        self
+      end
+
+      def version
+        @version ||= read_version
+      end
+
+      def write
+        return false unless valid?
+
+        self.class.write(file_data: to_h, file_path: file_path)
+        true
+      end
+
+      def write!
+        validate!
+
+        self.class.write(file_data: to_h, file_path: file_path)
+      end
+
+      alias save write
+      alias save! write!
+
+      class << self
+        def file_exist?(file_path:)
+          File.exist?(file_path)
+        end
+
+        def delete(file_path:)
+          return false unless file_exist?(file_path: file_path)
+
+          File.delete(file_path)
+
+          true
+        end
+
+        def delete!(file_path:)
+          raise file_does_not_exist_message(file_path: file_path) unless delete(file_path: file_path)
+        end
+
+        def parse(json)
+          return if json.nil?
+
+          JSON.parse(json, symbolize_names: true)
+        end
+
+        def read(file_path:)
+          json = File.read(file_path) if file_exist?(file_path: file_path)
+          hash = parse(json)
+          return yield hash if hash && block_given?
+
+          hash
+        end
+
+        def read!(file_path:)
+          raise file_does_not_exist_message(file_path: file_path) unless file_exist?(file_path: file_path)
+
+          hash = read(file_path: file_path)
+          return yield hash if hash && block_given?
+
+          hash
+        end
+
+        def write(file_data:, file_path:)
+          raise ArgumentError, 'file_data is nil' if file_data.nil?
+          raise ArgumentError, "file_data is the wrong object type:\"#{file_data}\"" unless file_data.is_a?(Hash)
+
+          file_data = JSON.pretty_generate(file_data)
+          File.write(file_path, file_data)
+        end
+
+        def write!(file_data:, file_path:)
+          # TODO: Should we be raising an error if the file does not exist?
+          # raise file_does_not_exist_message(file_path: file_path) unless file_exist?(file_path: file_path)
+
+          write(file_data: file_data, file_path: file_path)
+        end
+
+        def file_does_not_exist_message(file_path:)
+          "File \"#{file_path}\" does not exist"
+        end
+      end
+
+      private
+
+      attr_writer :file_path, :version
+
+      def read
+        hash = self.class.read(file_path: file_path)
+        return yield hash if block_given?
+
+        hash
+      end
+
+      def read!
+        hash = self.class.read!(file_path: file_path)
+        return yield hash if hash && block_given?
+
+        hash
+      end
+
+      def read_version
+        return 0 unless file_exist?
+
+        hash = read
+        return 0 if hash.nil?
+
+        hash.fetch(:version, 0).to_i
+      end
+    end
+  end
+end

data/lib/doto/env.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Doto
+  class << self
+    def env # rubocop:disable Metrics/MethodLength
+      @env ||= Struct.new(:env) do
+        def test?
+          env.fetch('DOTO_ENV', nil) == 'test'
+        end
+
+        def development?
+          env.fetch('DOTO_ENV', nil) == 'development'
+        end
+
+        def local?
+          test? || development?
+        end
+
+        def production?
+          env.fetch('DOTO_ENV', 'production') == 'production'
+        end
+
+        def screen_shot_mode?
+          development? && (env.fetch('SCREEN_SHOT_USERNAME', '').present? ||
+            env.fetch('SCREEN_SHOT_HOSTNAME', '').present?)
+        end
+
+        def screen_shot_prompt
+          username = screen_shot_username
+          hostname = screen_shot_hostname
+          "#{username}@#{hostname}:~ $"
+        end
+
+        def screen_shot_username
+          env.fetch('SCREEN_SHOT_USERNAME', 'username')
+        end
+
+        def screen_shot_hostname
+          env.fetch('SCREEN_SHOT_HOSTNAME', 'hostname')
+        end
+      end.new(ENV)
+    end
+  end
+end

data/lib/doto/migration/base_service.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative '../models/migration_version'
+require_relative '../support/fileable'
+require_relative 'version'
+
+module Doto
+  module Migration
+    class BaseService
+      include Support::Fileable
+
+      def initialize(options: {})
+        @options = options || {}
+      end
+
+      class << self
+        def migrates_to_latest_migration_version?
+          to_migration_version == Migration::VERSION
+        end
+
+        # The migration version that this migration is upgrading from.
+        def from_migration_version
+          raise NotImplementedError, 'You must implement the #from_migration_version method in your subclass'
+        end
+
+        # The migration version that this migration is upgrading to.
+        def to_migration_version
+          raise NotImplementedError, 'You must implement the #to_migration_version method in your subclass'
+        end
+      end
+
+      def migrate_if!
+        return unless run_migration?
+
+        puts "Running migrations #{from_migration_version} -> #{to_migration_version}..."
+        puts "\tpretend?: #{pretend?}" if pretend?
+
+        run_migration!
+        update_migration_version!
+
+        puts "\tMigration #{from_migration_version} -> #{to_migration_version} complete."
+      end
+
+      private
+
+      attr_accessor :options
+
+      # You must implement your own migration logic in your subclass and call this method.
+      def run_migration!
+        create_backup
+      end
+
+      def pretend?
+        options.fetch(:pretend, true)
+      end
+
+      def run_migration?
+        migration_version == from_migration_version
+      end
+
+      # The migration version that this migration is upgrading from.
+      def from_migration_version
+        self.class.from_migration_version
+      end
+
+      # The migration version that this migration is upgrading to.
+      def to_migration_version
+        self.class.to_migration_version
+      end
+
+      # The migration version before running this migration.
+      def migration_version
+        # Typically we should not be using models in any of the migration services
+        # because if these change, the migrations will break. However, using
+        # the MigrationVersion model is an exception because it is a very simple
+        # model and is unlikely to change.
+        Models::MigrationVersion.new.version
+      end
+
+      def create_backup
+        puts "Creating backup #{backup_folder}..."
+
+        return puts "\tSkipping: backup already exists." if backup_exist?
+
+        FileUtils.cp_r(doto_folder, backup_folder)
+        FileUtils.cp(config_path, backup_folder)
+      end
+
+      def backup_exist?
+        Dir.exist?(backup_folder)
+      end
+
+      def backup_folder
+        @backup_folder ||= backup_folder_for(migration_version: from_migration_version)
+      end
+
+      def update_migration_version!
+        puts 'Updating migration version...'
+
+        return if pretend? || migration_version == to_migration_version
+
+        Models::MigrationVersion.new(version: to_migration_version).save!
+      end
+
+      def seed_data_folder
+        seed_data_doto_folder_for(migration_version: to_migration_version)
+      end
+
+      def seed_data_configuration
+        seed_data_doto_configuration_for(migration_version: to_migration_version)
+      end
+
+      def raise_backup_folder_does_not_exist_error_if!
+        raise "Backup folder #{backup_folder} does not exist, cannot continue" unless backup_exist?
+      end
+    end
+  end
+end