dotfiler 0.1.0

data/lib/dotfiler/cli/commands/backup.rb

@@ -0,0 +1,36 @@
+module Dotfiler
+  module CLI
+    module Commands
+      class Backup < Command
+        BACKUP_DIR       = ".dotfiler_backup".freeze
+        TIMESTAMP_FORMAT = "%Y_%m_%d_%H_%M_%S".freeze
+
+        include Dotfiler::Import["copier", "remover"]
+
+        desc "Backup existing dotfiles directory"
+
+        def call(*)
+          handle_errors do
+            info("Backing up dotfiles directory (#{dotfiles_path}) to #{backup_dir_path}...")
+            copier.call(dotfiles_path, backup_dir_path)
+            remover.call(backup_dir_path.join(".git"), only_symlinks: false)
+          end
+        end
+
+        private
+
+        def backup_dir_path
+          config.home_path.join("#{BACKUP_DIR}_#{current_timestamp}")
+        end
+
+        def current_timestamp
+          Time.now.strftime(TIMESTAMP_FORMAT)
+        end
+
+        def dotfiles_path
+          to_path.(config[:dotfiles])
+        end
+      end
+    end
+  end
+end

data/lib/dotfiler/cli/commands/command.rb

@@ -0,0 +1,39 @@
+module Dotfiler
+  module CLI
+    module Commands
+      class Command < Hanami::CLI::Command
+        include Dotfiler::Import["config", "to_path", "shell"]
+
+        private
+
+        def handle_errors(&block)
+          begin
+            yield
+          rescue Dotfiler::Error => e
+            error!(e.message)
+          end
+        end
+
+        def print(*args)
+          shell.print(*args)
+        end
+
+        def info(message)
+          print(message, :info)
+        end
+
+        def error!(message)
+          terminate!(:error, message: message)
+        end
+
+        def terminate!(*args)
+          shell.terminate(*args)
+        end
+
+        def prompt(*args)
+          shell.prompt(*args)
+        end
+      end
+    end
+  end
+end

data/lib/dotfiler/cli/commands/edit.rb

@@ -0,0 +1,37 @@
+module Dotfiler
+  module CLI
+    module Commands
+      class Edit < Command
+        include Dotfiler::Import["fs", "dotfiles"]
+
+        desc "Edit specified dotfile. By default, dotfile will be opened in $EDITOR"
+
+        argument :name, required: true, desc: "Name of the dotfile you want to edit"
+        option :with, aliases: ["w"], required: false, desc: "Editor in which to open the specified dotfile"
+
+        def call(name:, **options)
+          handle_errors do
+            validate_name!(name)
+
+            dotfile_path = dotfiles.find(name).path.to_s
+            editor       = options.fetch(:with, default_editor)
+
+            error!("Editor is not specified. Either set the '$EDITOR' environment variable or provide '--with' option") unless editor
+
+            fs.execute(editor, dotfile_path)
+          end
+        end
+
+        private
+
+        def validate_name!(name)
+          error!("Dotfile '#{name}' not found") unless dotfiles.exists?(name)
+        end
+
+        def default_editor
+          ENV["EDITOR"]
+        end
+      end
+    end
+  end
+end

data/lib/dotfiler/cli/commands/init.rb

@@ -0,0 +1,79 @@
+module Dotfiler
+  module CLI
+    module Commands
+      class Init < Command
+        include Dotfiler::Import["fs"]
+
+        desc "Create config file. Create dotfiles directory at specified path. Initialize git repo."
+
+        argument :path, required: true, desc: "Path where the Dotfiles directory will be created"
+        option :git, type: :boolean, default: true, desc: "Initialize git repo for dotfiles directory"
+
+        def call(path:, **options)
+          handle_errors do
+            dotfiles_path = to_path.(path)
+
+            create_config_file(config_file_contents(dotfiles_path))
+            create_dotfiles_dir(dotfiles_path)
+            create_dotfiles_file(dotfiles_path)
+            initialize_vcs_repo(dotfiles_path) unless options[:git] == false
+          end
+        end
+
+        private
+
+        def config_file_contents(dotfiles_path)
+          "dotfiles: #{dotfiles_path.to_s}"
+        end
+
+        def create_config_file(contents)
+          if config.file_path.exists?
+            answer = prompt("Config file (#{config.file_path}) already exists. Would you like to overwrite it?")
+
+            return unless answer == :yes
+          end
+
+          info("Creating config file (#{config.file_path})...")
+          fs.create_file(config.file_path.to_s, contents)
+        end
+
+        def create_dotfiles_dir(dotfiles_path)
+          if dotfiles_path.exists?
+            answer = prompt("Dotfiles directory (#{dotfiles_path}) already exists. Would you like to overwrite it?")
+
+            return unless answer == :yes
+
+            info("Removing existing dotfiles directory (#{dotfiles_path})...")
+            fs.remove(dotfiles_path.to_s)
+          end
+
+          info("Creating dotfiles directory (#{dotfiles_path})...")
+          fs.create_dir(dotfiles_path.to_s)
+        end
+
+        def create_dotfiles_file(dotfiles_path)
+          dotfiles_file = dotfiles_path.join(config.dotfiles_file_name)
+
+          if dotfiles_file.exists?
+            answer = prompt("Dotfiles file (#{dotfiles_file}) already exists. Would you like to overwrite it?")
+
+            return unless answer == :yes
+          end
+
+          info("Creating dotfiles file (#{dotfiles_file})...")
+          fs.create_file(dotfiles_file.to_s)
+        end
+
+        def initialize_vcs_repo(dotfiles_path)
+          if dotfiles_path.join(".git").exists?
+            answer = prompt("Dotfiles dir (#{dotfiles_path}) is already a git repository. Would you like to reinitialize it?")
+
+            return unless answer == :yes
+          end
+
+          info(fs.execute("git", "init", dotfiles_path.to_s, capture: true))
+        end
+      end
+    end
+  end
+end

data/lib/dotfiler/cli/commands/install.rb

@@ -0,0 +1,69 @@
+module Dotfiler
+  module CLI
+    module Commands
+      class Install < Command
+        BACKUP_DIR       = "dotfiler_installation_backup".freeze
+        TIMESTAMP_FORMAT = "%Y_%m_%d_%H_%M_%S".freeze
+
+        include Dotfiler::Import[ "fs", "dotfiles", "mover", "symlinker"]
+
+        desc "Install dotfiles from existing dotfiles directory"
+
+        argument :path, required: true, desc: "Path to existing dotfiles directory"
+
+        def call(path: , **options)
+          handle_errors do
+            dotfiles_path = to_path.(path)
+
+            validate_dotfiles_file!(dotfiles_path)
+
+            configure_dotfiles_dir(dotfiles_path)
+
+            config.reload!
+            dotfiles.config.reload!
+            dotfiles.reload!
+
+            create_symlinks
+          end
+        end
+
+        private
+
+        def validate_dotfiles_file!(dotfiles_path)
+          dotfiles_path = dotfiles_path.join(config.dotfiles_file_name)
+
+          return if dotfiles_path.file?
+
+          error!("Dotfiles file (#{dotfiles_path}) not found...")
+        end
+
+        def configure_dotfiles_dir(dotfiles_path)
+          config.update!(dotfiles: dotfiles_path.to_s)
+        end
+
+        def create_symlinks
+          dotfiles.each do |dotfile|
+            backup(dotfile.link) if dotfile.link.exists? && !dotfile.link.symlink?
+
+            info("Symlinking dotfile (#{dotfile.path}) to #{dotfile.link}...")
+            symlinker.call(dotfile.path, dotfile.link, force: true)
+          end
+        end
+
+        def backup(path)
+          fs.create_dir(backup_dir_path.to_s) unless backup_dir_path.exists?
+          info("Backing up #{path} to #{backup_dir_path}...")
+          mover.call(path, backup_dir_path)
+        end
+
+        def backup_dir_path
+          @_backup_dir_path ||= config.home_path.join("#{BACKUP_DIR}_#{current_timestamp}")
+        end
+
+        def current_timestamp
+          Time.now.strftime(TIMESTAMP_FORMAT)
+        end
+      end
+    end
+  end
+end

data/lib/dotfiler/cli/commands/list.rb

@@ -0,0 +1,43 @@
+module Dotfiler
+  module CLI
+    module Commands
+      class List < Command
+        include Dotfiler::Import["dotfiles"]
+
+        desc "List all managed dotfiles"
+
+        argument :names, desc: "List only names of managed dotfiles"
+
+        def call(names: nil)
+          handle_errors do
+            if dotfiles.list.empty?
+              terminate!(:info, message: "No dotfiles are managed at the moment")
+            else
+              content = generate_list(names_only: !names.nil?)
+              shell.print(content)
+            end
+          end
+        end
+
+        private
+
+        def generate_list(names_only: false)
+          content = ""
+
+          dotfiles.each do |dotfile|
+            name, link, path = dotfile.to_h.values_at(:name, :link, :path)
+
+            content += "  #{name}\n"
+
+            if !names_only
+              content += "    - LINK: #{link}\n"
+              content += "    - PATH: #{path}\n\n"
+            end
+          end
+
+          content
+        end
+      end
+    end
+  end
+end

data/lib/dotfiler/cli/commands/remove.rb

@@ -0,0 +1,39 @@
+module Dotfiler
+  module CLI
+    module Commands
+      class Remove < Command
+        include Dotfiler::Import["dotfiles", "mover", "remover"]
+
+        desc "Remove specified dotfile from dotfiles and restore it to it's original location"
+
+        argument :name, required: true, desc: "Name of the dotfile that should be unlinked"
+
+        def call(name:)
+          handle_errors do
+            validate_name!(name)
+
+            dotfile = dotfiles.find(name)
+
+            info("Removing symlink (#{dotfile.link})...")
+            remover.call(dotfile.link)
+
+            info("Restoring dotfile (#{dotfile.path}) to its original location (#{dotfile.link})...")
+            mover.call(dotfile.path, dotfile.link)
+
+
+            info("Removing '#{name}' from dotfiles...")
+            dotfiles.remove!(name)
+          end
+        end
+
+        private
+
+        def validate_name!(name)
+          return if dotfiles.exists?(name)
+
+          shell.terminate(:error, message: "Dotfile with the name '#{name}' does not exist")
+        end
+      end
+    end
+  end
+end

data/lib/dotfiler/cli/commands/version.rb

@@ -0,0 +1,13 @@
+module Dotfiler
+  module CLI
+    module Commands
+      class Version < Command
+        desc "Show version"
+
+        def call(*)
+          print("dotfiler #{Dotfiler::VERSION}")
+        end
+      end
+    end
+  end
+end

data/lib/dotfiler/config.rb

@@ -0,0 +1,71 @@
+require "yaml"
+
+module Dotfiler
+  class Config
+    CONFIG_FILE        = ".dotfiler".freeze
+    DOTFILES_FILE      = ".dotfiles".freeze
+    RELATIVE_HOME_PATH = "~".freeze
+
+    include Dotfiler::Import["fs", "to_path"]
+
+    def initialize(*args)
+      super
+      @data = load_data
+    end
+
+    def [](setting)
+      @data[setting]
+    end
+
+    def file_path
+      @_file_path ||= home_path.join(CONFIG_FILE)
+    end
+
+    def home_path
+      @_home_path ||= path(ENV["DOTFILER_HOME"] || Dir.home)
+    end
+
+    def relative_home_path
+      @_relative_home_path ||= path(RELATIVE_HOME_PATH, expand: false)
+    end
+
+    def set?
+      file_path.exists?
+    end
+
+    def dotfiles_file_path
+      path(self[:dotfiles]).join(dotfiles_file_name) if set?
+    end
+
+    def dotfiles_file_name
+      DOTFILES_FILE
+    end
+
+    def reload!
+      @data = load_data
+    end
+
+    def update!(args = {})
+      new_data     = @data.merge(args)
+      file_content = new_data.each_with_object([]) { |(k, v), result| result << "#{k}: #{v}" }.join("\n")
+
+      fs.create_file(file_path.to_s, file_content)
+
+      reload!
+    end
+
+    private
+
+    def path(input, *opts)
+      to_path.(input, *opts)
+    end
+
+    def load_data
+      return {} unless set?
+
+      (YAML.load_file(file_path.to_s) || {}).each_with_object({}) do |(setting, value), result|
+        result[setting.to_sym] = value
+      end
+    end
+  end
+end

data/lib/dotfiler/container.rb

@@ -0,0 +1,58 @@
+require "dry-container"
+require "dry-auto_inject"
+
+module Dotfiler
+  class Container
+    extend Dry::Container::Mixin
+
+    register "to_path", memoize: true do
+      Dotfiler::Path.method(:new)
+    end
+
+    register "fs", memoize: true do
+      Dotfiler::FileSystem.new
+    end
+
+    register "config", memoize: false do
+      Dotfiler::Config.new
+    end
+
+    register "dotfiles", memoize: false do
+      Dotfiler::Dotfiles.new
+    end
+
+    register "copier", memoize: true do
+      Dotfiler::Copier.new
+    end
+
+    register "mover", memoize: true do
+      Dotfiler::Mover.new
+    end
+
+    register "symlinker", memoize: true do
+      Dotfiler::Symlinker.new
+    end
+
+    register "remover", memoize: true do
+      Dotfiler::Remover.new
+    end
+
+    register "shell", memoize: true do
+      Dotfiler::Shell.new
+    end
+  end
+
+  Import = Dry::AutoInject(Container)
+end
+
+require "dotfiler/path"
+require "dotfiler/file_system"
+require "dotfiler/config"
+require "dotfiler/dotfiles"
+
+require "dotfiler/copier"
+require "dotfiler/mover"
+require "dotfiler/symlinker"
+require "dotfiler/remover"
+
+require "dotfiler/shell"