dotsync 0.1.0

data/lib/dotsync/actions/config/mapping_entry.rb

@@ -0,0 +1,65 @@
+module Dotsync
+  class MappingEntry
+    include Dotsync::PathUtils
+
+    attr_reader :original_src, :original_dest, :original_ignores
+
+    def initialize(hash)
+      @original_src = hash["src"]
+      @original_dest = hash["dest"]
+      @original_ignores = Array(hash["ignore"])
+      @force = hash["force"] || false
+
+      @sanitized_src = sanitize_path(@original_src)
+      @sanitized_dest = sanitize_path(@original_dest)
+      @sanitized_ignore = @original_ignores.map { |path| File.join(@sanitized_src, path) }
+    end
+
+    def src
+      @sanitized_src
+    end
+
+    def dest
+      @sanitized_dest
+    end
+
+    def ignores
+      @sanitized_ignore
+    end
+
+    def force?
+      @force
+    end
+
+    def valid?
+      File.exist?(@sanitized_src) && File.exist?(@sanitized_dest)
+    end
+
+    def to_s
+      force_icon = force? ? "  #{icon_delete}" : ""
+      "#{original_src} → #{original_dest}#{force_icon}"
+    end
+
+    def applied_to(path)
+      relative_path = if Pathname.new(path).absolute?
+        path.delete_prefix(File.join(src, "/"))
+      else
+        path
+      end
+
+      Dotsync::MappingEntry.new(
+        "src" => File.join(@original_src, relative_path),
+        "dest" => File.join(@original_dest, relative_path),
+        "force" => @force,
+        "ignore" => @original_ignores
+      )
+    end
+
+    private
+
+    def icon_delete
+      Dotsync::Logger::ICONS[:delete]
+    end
+  end
+end
+

data/lib/dotsync/actions/config/pull_action_config.rb

@@ -0,0 +1,33 @@
+module Dotsync
+  class PullActionConfig < BaseConfig
+    include XDGBaseDirectorySpec
+
+    def mappings
+      mappings_list = section["mappings"]
+      Array(mappings_list).map { |mapping| Dotsync::MappingEntry.new(mapping) }
+    end
+
+    def backups_root
+      File.join(xdg_data_home, "dotsync", "backups")
+    end
+
+    private
+
+      SECTION_NAME = "pull"
+
+      def section_name
+        SECTION_NAME
+      end
+
+      def validate!
+        validate_section_present!
+        validate_key_present! "mappings"
+
+        Array(section["mappings"]).each_with_index do |mapping, index|
+          unless mapping.is_a?(Hash) && mapping.key?("src") && mapping.key?("dest")
+            raise "Configuration error in mapping ##{index + 1}: Each mapping must have 'src' and 'dest' keys."
+          end
+        end
+      end
+  end
+end

data/lib/dotsync/actions/config/push_action_config.rb

@@ -0,0 +1,27 @@
+module Dotsync
+  class PushActionConfig < BaseConfig
+    def mappings
+      mappings_list = section["mappings"]
+      Array(mappings_list).map { |mapping| Dotsync::MappingEntry.new(mapping) }
+    end
+
+    private
+
+      SECTION_NAME = "push"
+
+      def section_name
+        SECTION_NAME
+      end
+
+      def validate!
+        validate_section_present!
+        validate_key_present! "mappings"
+
+        Array(section["mappings"]).each_with_index do |mapping, index|
+          unless mapping.is_a?(Hash) && mapping.key?("src") && mapping.key?("dest")
+            raise "Configuration error in mapping ##{index + 1}: Each mapping must have 'src' and 'dest' keys."
+          end
+        end
+      end
+  end
+end

data/lib/dotsync/actions/config/watch_action_config.rb

@@ -0,0 +1,12 @@
+module Dotsync
+  class WatchActionConfig < PushActionConfig
+
+    private
+
+      SECTION_NAME = "watch"
+
+      def section_name
+        SECTION_NAME
+      end
+  end
+end

data/lib/dotsync/actions/config/xdg_base_directory_spec.rb

@@ -0,0 +1,20 @@
+module Dotsync
+  # https://specifications.freedesktop.org/basedir-spec/latest/
+  module XDGBaseDirectorySpec
+    def xdg_data_home
+      File.expand_path(ENV["XDG_DATA_HOME"] || "$HOME/.local/share")
+    end
+
+    def xdf_config_home
+      File.expand_path(ENV["XDG_CONFIG_HOME"] || "$HOME/.config")
+    end
+
+    def xdf_cache_home
+      File.expand_path(ENV["XDG_CACHE_HOME"] || "$HOME/.cache")
+    end
+
+    def xdf_bin_home
+      File.expand_path(ENV["XDG_BIN_HOME"] || "$HOME/.local/bin")
+    end
+  end
+end

data/lib/dotsync/actions/pull_action.rb

@@ -0,0 +1,74 @@
+module Dotsync
+  class PullAction < BaseAction
+    def_delegator :@config, :mappings
+    def_delegator :@config, :backups_root
+
+    def execute
+      show_config
+      if create_backup
+        show_backup
+        purge_old_backups
+      end
+      pull_dotfiles
+    end
+
+    private
+
+      def show_config
+        info("Mappings:", icon: :source_dest)
+        mappings.each do |mapping|
+          force_icon = mapping.force? ? " #{icon_delete}" : ""
+          info("  src: #{mapping.original_src} -> dest: #{mapping.original_dest}#{force_icon}", icon: :copy)
+          info("    ignores: #{mapping.ignores.join(', ')}", icon: :exclude) if mapping.ignores.any?
+        end
+      end
+
+      def show_backup
+        action("Backup created:", icon: :backup)
+        info("  #{backup_path}")
+      end
+
+      def timestamp
+        Time.now.strftime('%Y%m%d%H%M%S')
+      end
+
+      def backup_path
+        @backup_path ||= File.join(backups_root, timestamp)
+      end
+
+      def create_backup
+        return false unless mappings.any? { |mapping| File.exist?(mapping.dest) }
+        FileUtils.mkdir_p(backup_path)
+        mappings.each do |mapping|
+          next unless File.exist?(mapping.dest)
+          if File.file?(mapping.src)
+            FileUtils.cp(mapping.dest, File.join(backup_path, File.basename(mapping.dest)))
+          else
+            FileUtils.cp_r(mapping.dest, File.join(backup_path, File.basename(mapping.dest)))
+          end
+        end
+        true
+      end
+
+      def purge_old_backups
+        backups = Dir[File.join(backups_root, '*')].sort.reverse
+        if backups.size > 10
+          info("Maximum of 10 backups retained")
+
+          backups[10..].each do |path|
+            FileUtils.rm_rf(path)
+            info("Old backup deleted: #{path}", icon: :delete)
+          end
+        end
+      end
+
+      def pull_dotfiles
+        mappings.each { |mapping| Dotsync::FileTransfer.new(mapping).transfer }
+        action("Dotfiles pulled", icon: :copy)
+      end
+
+      def icon_delete
+        Dotsync::Logger::ICONS[:delete]
+      end
+  end
+end

data/lib/dotsync/actions/push_action.rb

@@ -0,0 +1,30 @@
+module Dotsync
+  class PushAction < BaseAction
+    def_delegator :@config, :mappings
+
+    def execute
+      show_config
+      push_dotfiles
+    end
+
+    private
+
+    def show_config
+      info("Mappings:", icon: :source_dest)
+      mappings.each do |mapping|
+        force_icon = mapping.force? ? " #{icon_delete}" : ""
+        info("  src: #{mapping.original_src} -> dest: #{mapping.original_dest}#{force_icon}", icon: :copy)
+        info("    ignores: #{mapping.original_ignores.join(', ')}", icon: :exclude) if mapping.ignores.any?
+      end
+    end
+
+    def push_dotfiles
+      mappings.each { |mapping| Dotsync::FileTransfer.new(mapping).transfer }
+      action("Dotfiles pushed", icon: :copy)
+    end
+
+    def icon_delete
+      Dotsync::Logger::ICONS[:delete]
+    end
+  end
+end

data/lib/dotsync/actions/watch_action.rb

@@ -0,0 +1,75 @@
+module Dotsync
+  class WatchAction < BaseAction
+    def_delegator :@config, :mappings
+
+    def initialize(config, logger)
+      super
+      setup_listeners
+      setup_logger_thread
+      setup_signal_trap
+    end
+
+    def execute
+      show_config
+
+      @listeners.each(&:start)
+
+      logger.action("Listening for changes...", icon: :listen)
+      info("Press Ctrl+C to exit.")
+      sleep
+    end
+
+    private
+
+      def show_config
+        info("Mappings:", icon: :watch)
+        mappings.each do |mapping|
+          info("  #{mapping}", icon: :copy)
+          info("    Excludes: #{mapping.ignores.join(', ')}", icon: :exclude) if mapping.ignores.any?
+        end
+      end
+
+      def setup_listeners
+        @listeners = mappings.map do |mapping|
+          src = mapping.src
+
+          # Determine the base directory to watch. If it's a directory, use it directly.
+          # Otherwise, use its parent directory.
+          base = File.directory?(src) ? src : File.dirname(src)
+
+          options = {}
+          # If the watched path is a file, create a pattern to match its name.
+          options[:pattern] = /^#{Regexp.escape(File.basename(src))}$/ unless File.directory?(src)
+          options[:ignore] = Regexp.union(mapping.ignores) if mapping.ignores.any?
+
+          Listen.to(base, options) do |modified, added, removed|
+            handle_file_changes(mapping, modified, added, removed)
+          end
+        end
+      end
+
+      def handle_file_changes(mapping, modified, added, removed)
+        (modified + added).each do |path|
+          new_mapping = mapping.applied_to(path)
+          logger.info("Copied file: #{new_mapping.original_src}", icon: :copy)
+          Dotsync::FileTransfer.new(new_mapping).transfer
+        end
+        removed.each do |path|
+          logger.info("File removed: #{path}", icon: :delete)
+        end
+      end
+
+      def setup_signal_trap
+        listeners = @listeners.dup
+        Signal.trap("INT") do
+          # Using a new thread to handle the signal trap context,
+          # as Signal.trap runs in a more restrictive environment
+          Thread.new do
+            logger.action("Shutting down listeners...", icon: :bell)
+            listeners.each(&:stop)
+            exit
+          end
+        end
+      end
+  end
+end

data/lib/dotsync/errors.rb

@@ -0,0 +1,3 @@
+module Dotsync
+  class ConfigError < StandardError; end
+end

data/lib/dotsync/file_transfer.rb

@@ -0,0 +1,49 @@
+module Dotsync
+  class FileTransfer
+    attr_reader :ignores
+
+    def initialize(config)
+      @src = config.src
+      @dest = config.dest
+      @force = config.force?
+      @ignores = config.ignores || []
+    end
+
+    def transfer
+      if File.file?(@src)
+        transfer_file(@src, @dest)
+      else
+        FileUtils.rm_rf(Dir.glob(File.join(@dest, '*'))) if @force
+        transfer_folder(@src, @dest)
+      end
+    end
+
+    private
+
+    def transfer_file(file_src, file_dest)
+      FileUtils.mkdir_p(File.dirname(file_dest))
+      FileUtils.cp(file_src, file_dest)
+    end
+
+    def transfer_folder(folder_src, folder_dest)
+      FileUtils.mkdir_p(folder_dest)
+      Dir.glob("#{folder_src}/*", File::FNM_DOTMATCH).each do |path|
+        next if ['.', '..'].include?(File.basename(path))
+
+        full_path = File.expand_path(path)
+        next if ignore?(full_path)
+
+        target = File.join(folder_dest, File.basename(path))
+        if File.file?(full_path)
+          FileUtils.cp(full_path, target)
+        else
+          transfer_folder(full_path, target)
+        end
+      end
+    end
+
+    def ignore?(path)
+      @ignores.any? { |ignore| path.start_with?(ignore) }
+    end
+  end
+end

data/lib/dotsync/logger.rb

@@ -0,0 +1,61 @@
+module Dotsync
+  class Logger
+    attr_accessor :output
+
+    # 🎨 Nerd Font Icons
+    ICONS = {
+      info:    " ",
+      listen:  " ",
+      error:   " ",
+      watch:   " ",
+      source:  " ", #  ",
+      dest:    " ", # " ",
+      delete:  " ",
+      bell:    " ",
+      copy:    " ",
+      skip:    " ",
+      done:    " ",
+      backup:  " ",
+      clean:   " ",
+    }
+
+    def initialize(output = $stdout)
+      @output = output
+    end
+
+    def info(message, options = {})
+      log(:info, message, options)
+    end
+
+    def action(message, options = {})
+      log(:action, message, options)
+    end
+
+    def success(message)
+      log(:success, message, icon: :done)
+    end
+
+    def error(message)
+      log(:error, message, icon: :error)
+    end
+
+    def warning(message, options = {})
+      log(:warning, message, options)
+    end
+
+    def log(type, message, options = {})
+      icon = options[:icon]
+      color = {
+        info: 103, action: 153, error: 196, event: 141, warning: 31, copy: 32,
+        skip: 33, done: 32, backup: 35,
+        clean: 34
+      }[type] || 0
+
+      if icon.nil?
+        @output.puts message
+      else
+        @output.puts "\e[38;5;#{color}m\e[1m#{ICONS[icon]}#{message}\e[0m"
+      end
+    end
+  end
+end

data/lib/dotsync/path_utils.rb

@@ -0,0 +1,26 @@
+module Dotsync
+  module PathUtils
+    def expand_env_vars(path)
+      path.gsub(/\$(\w+)/) { ENV[$1] }
+    end
+
+    # Translates /tmp paths to /private/tmp paths on macOS
+    # Retains other paths as-is
+    # @param [String] path The input path to translate
+    # @return [String] The translated path
+    def translate_tmp_path(path)
+      if path.start_with?('/tmp') && RUBY_PLATFORM.include?('darwin')
+        path.sub('/tmp', '/private/tmp')
+      else
+        path
+      end
+    end
+
+    # Sanitizes a given path by expanding it and translating /tmp to /private/tmp
+    # @param [String] path The input path to sanitize
+    # @return [String] The sanitized path
+    def sanitize_path(path)
+      translate_tmp_path(File.expand_path(expand_env_vars(path)))
+    end
+  end
+end

data/lib/dotsync/runner.rb

@@ -0,0 +1,36 @@
+module Dotsync
+  class Runner
+    def initialize(logger: nil)
+      @logger = logger || Dotsync::Logger.new
+    end
+
+    # action_name should be a symbol, e.g., :pull, :watch, :sync
+    def run(action_name)
+      begin
+        action_class = Dotsync.const_get("#{camelize(action_name.to_s)}Action")
+        config_class = Dotsync.const_get("#{camelize(action_name.to_s)}ActionConfig")
+
+        config = config_class.new(Dotsync.config_path)
+        action = action_class.new(config, @logger)
+        action.execute
+      rescue ConfigError => e
+        @logger.error("[#{action_name}] config error:")
+        @logger.info(e.message)
+      rescue NameError => e
+        @logger.error("Unknown action '#{action_name}':")
+        @logger.info(e.message)
+      rescue => e
+        @logger.error("Error running '#{action_name}':")
+        @logger.info(e.message)
+        raise
+      end
+    end
+
+    private
+
+    # Utility to convert 'pull' to 'Pull', 'sync' to 'Sync', etc.
+    def camelize(str)
+      str.split('_').map(&:capitalize).join
+    end
+  end
+end

data/lib/dotsync/tasks/actions.rake

@@ -0,0 +1,10 @@
+desc "Sync Dotfiles"
+task :sync do
+  ds = Dotsync::SyncAction.new
+end
+
+desc "Watch Dotfiles"
+task :watch do
+  action = Dotsync::WatchAction.new
+  action.start
+end

data/lib/dotsync/version.rb

@@ -0,0 +1,3 @@
+module Dotsync
+  VERSION = "0.1.0"
+end

data/lib/dotsync.rb

@@ -0,0 +1,45 @@
+# Libs dependencies
+require 'fileutils'
+require 'listen'
+require 'toml-rb'
+require 'logger'
+require 'forwardable' # Ruby standard library
+require 'ostruct'
+
+# Errors
+require_relative "dotsync/errors"
+
+# Utils
+require_relative 'dotsync/logger'
+require_relative 'dotsync/file_transfer'
+require_relative 'dotsync/path_utils'
+
+# Config
+require_relative "dotsync/actions/config/xdg_base_directory_spec"
+require_relative "dotsync/actions/config/mapping_entry"
+require_relative "dotsync/actions/config/base_config"
+require_relative "dotsync/actions/config/pull_action_config"
+require_relative "dotsync/actions/config/push_action_config"
+require_relative "dotsync/actions/config/watch_action_config"
+
+# Actions
+require_relative "dotsync/actions/base_action"
+require_relative "dotsync/actions/pull_action"
+require_relative "dotsync/actions/push_action"
+require_relative "dotsync/actions/watch_action"
+
+require_relative 'dotsync/runner'
+
+require_relative "dotsync/version"
+
+module Dotsync
+  class Error < StandardError; end
+
+  class << self
+    attr_writer :config_path
+
+    def config_path
+      @config_path ||= ENV['DOTSYNC_CONFIG'] || "~/.config/dotsync.toml"
+    end
+  end
+end