dotsync-cli 1.0.2__py3-none-any.whl

dotsync/args.py

@@ -0,0 +1,149 @@
+import logging
+import argparse
+import os
+
+from dotsync.enums import Actions
+import dotsync.info as info
+
+HELP = {
+    'verbose': 'increase verbosity level',
+    'dry-run': 'do not actually execute any file operations',
+    'hard-mode': 'copy files instead of symlinking them',
+    'action': 'action to take on active categories',
+    'category': 'categories to activate (default: common + hostname)'
+}
+
+EPILOG = 'See full the documentation at https://dotsync.readthedocs.io/'
+
+
+class CustomHelpFormatter(argparse.RawDescriptionHelpFormatter):
+    """Custom formatter that hides default values containing hostname"""
+    def _get_help_string(self, action):
+        help_text = action.help
+        # Replace %(default)s placeholder
+        if '%(default)s' in help_text:
+            if action.dest == 'category':
+                default = action.default
+                if isinstance(default, list) and len(default) == 2 and default[1] == info.hostname:
+                    help_text = help_text.replace('%(default)s', 'common + hostname')
+                else:
+                    help_text = help_text % {'default': default}
+            else:
+                help_text = help_text % {'default': action.default}
+        return help_text
+    
+    def _format_action(self, action):
+        """Override to hide default display for category argument"""
+        # Temporarily remove default to prevent argparse from showing it
+        if action.dest == 'category' and hasattr(action, 'default'):
+            original_default = action.default
+            # Replace with SUPPRESS to hide it from help output
+            action.default = argparse.SUPPRESS
+        
+        # Format the action
+        result = super()._format_action(action)
+        
+        # Restore original default
+        if action.dest == 'category' and 'original_default' in locals():
+            action.default = original_default
+        
+        return result
+
+
+class Arguments:
+    def __init__(self, args=None):
+        # construct parser
+        parser = argparse.ArgumentParser(prog='dotsync',
+                                         epilog=EPILOG,
+                                         formatter_class=CustomHelpFormatter)
+
+        # add parser options
+        parser.add_argument('--version', action='version',
+                            version=f'dotsync {info.__version__}')
+        parser.add_argument('--verbose', '-v', action='count', default=0,
+                            help=HELP['verbose'])
+        parser.add_argument('--dry-run', action='store_true',
+                            help=HELP['dry-run'])
+        parser.add_argument('--hard', action='store_true',
+                            help=HELP['hard-mode'])
+        parser.add_argument('--encrypt', action='store_true',
+                            help='encrypt the file (for add command)')
+
+        parser.add_argument('action', choices=[a.value for a in Actions],
+                            help=HELP['action'])
+        # For 'add' action: category[0] is filepath, category[1] is optional category name
+        # For 'encrypt' action: category[0] is filepath
+        # For 'unmanage' action: category[0] is filepath
+        # For other actions: category is list of category names
+        category_help = HELP['category']
+        add_help = 'filepath [category] - add new config file to filelist'
+        encrypt_help = 'filepath - convert existing config file to encrypted'
+        unmanage_help = 'filepath - restore file to home and stop managing it'
+        
+        # For init: category[0] is optional directory path (defaults to ~/.dotfiles)
+        init_help = '[directory] - initialize dotsync repository (default: ~/.dotfiles)'
+        category_help_extended = f'{category_help} (for "init": {init_help}, for "add": {add_help}, for "encrypt": {encrypt_help}, for "unmanage": {unmanage_help})'
+        
+        parser.add_argument('category', nargs='*',
+                            default=['common', info.hostname],
+                            help=category_help_extended)
+
+        # parse args
+        args = parser.parse_args(args)
+        
+        # For init action, category[0] is optional directory path
+        if args.action == 'init':
+            # Check if user provided a directory (not the default categories)
+            # Default is ['common', info.hostname], so if category doesn't match this pattern, it's a directory
+            if len(args.category) > 0:
+                # If category looks like a path (contains / or starts with ~ or is absolute), it's a directory
+                first_arg = args.category[0]
+                if ('/' in first_arg or first_arg.startswith('~') or os.path.isabs(first_arg) or 
+                    first_arg not in ['common']):
+                    # User provided a directory
+                    self.init_directory = first_arg
+                else:
+                    # Probably default categories, use default directory
+                    self.init_directory = None
+            else:
+                # No arguments, use default directory
+                self.init_directory = None
+        # For add action, category[0] is filepath, category[1] is category name
+        elif args.action == 'add':
+            if len(args.category) < 1:
+                parser.error('add action requires at least one argument: filepath [category]')
+            self.add_filepath = args.category[0]
+            self.add_category = args.category[1] if len(args.category) > 1 else None
+        # For encrypt action, category[0] is filepath
+        elif args.action == 'encrypt':
+            if len(args.category) < 1:
+                parser.error('encrypt action requires filepath argument')
+            self.add_filepath = args.category[0]
+            self.add_category = None
+        # For unmanage action, category[0] is filepath
+        elif args.action == 'unmanage':
+            if len(args.category) < 1:
+                parser.error('unmanage action requires filepath argument')
+            self.add_filepath = args.category[0]
+            self.add_category = None
+        else:
+            self.add_filepath = None
+            self.add_category = None
+            self.init_directory = None
+
+        # extract settings
+        if args.verbose:
+            args.verbose = min(args.verbose, 2)
+            self.verbose_level = (logging.INFO if args.verbose < 2 else
+                                  logging.DEBUG)
+        else:
+            self.verbose_level = logging.WARNING
+
+        self.dry_run = args.dry_run
+        self.hard_mode = args.hard
+        self.encrypt = getattr(args, 'encrypt', False)
+        self.action = Actions(args.action)
+        self.categories = args.category
+
+    def __str__(self):
+        return str(vars(self))

dotsync/calc_ops.py

@@ -0,0 +1,298 @@
+import os
+import logging
+
+from dotsync.file_ops import FileOps
+
+
+class CalcOps:
+    def __init__(self, repo, restore_path, plugin):
+        self.repo = str(repo)
+        self.restore_path = str(restore_path)
+        self.plugin = plugin
+
+    def update(self, files):
+        fops = FileOps(self.repo)
+
+        for path in files:
+            categories = files[path]
+
+            master = min(categories)
+            slaves = [c for c in categories if c != master]
+
+            # checks if a candidate exists and also checks if the candidate is
+            # a link so that its resolved path can be used
+            original_path = {}
+
+            def check_cand(cand):
+                cand = os.path.join(cand, path)
+                if os.path.isfile(cand):
+                    if os.path.islink(cand):
+                        old = cand
+                        cand = os.path.realpath(cand)
+                        original_path[cand] = old
+                    return [cand]
+                return []
+
+            candidates = []
+            candidates += check_cand(self.restore_path)
+
+            # candidate not found in restore path, so check elsewhere
+            if not candidates:
+                for cand in [os.path.join(self.repo, c) for c in categories]:
+                    candidates += check_cand(cand)
+            else:
+                logging.debug(f'"{path}" found in restore path, so overriding '
+                              'any other candidates')
+
+            if not candidates:
+                logging.warning(f'unable to find any candidates for "{path}"')
+                continue
+
+            candidates = list(set(candidates))
+            if len(candidates) > 1:
+                print(f'multiple candidates found for {path}:\n')
+
+                for i, cand in enumerate(candidates):
+                    print(f'[{i}] {cand}')
+                print('[-1] cancel')
+
+                while True:
+                    try:
+                        choice = int(input('please select the version you '
+                                           'would like to use '
+                                           f'[0-{len(candidates)-1}]: '))
+                        choice = candidates[choice]
+                    except (ValueError, EOFError):
+                        print('invalid choice entered, please try again')
+                        continue
+                    break
+                source = choice
+
+                # if one of the candidates is not in the repo and it is not the
+                # source it should be deleted manually since it will not be
+                # deleted in the slave linking below, as the other candidates
+                # would be
+                restore_path = os.path.join(self.restore_path, path)
+                if restore_path in candidates and source != restore_path:
+                    fops.remove(restore_path)
+
+            else:
+                source = candidates.pop()
+
+            master = os.path.join(self.repo, master, path)
+            slaves = [os.path.join(self.repo, s, path) for s in slaves]
+
+            if source != master and not self.plugin.samefile(master, source):
+                if os.path.exists(master):
+                    fops.remove(master)
+                # check if source is in repo, if it is not apply the plugin
+                if source.startswith(self.repo + os.sep):
+                    # if the source is one of the slaves, move the source
+                    # otherwise just copy it because it might have changed into
+                    # a seperate category - cleanup will remove it if needed
+                    if source in slaves:
+                        fops.move(source, master)
+                    else:
+                        fops.copy(source, master)
+                else:
+                    fops.plugin(self.plugin.apply, source, master)
+                    if source in original_path:
+                        fops.remove(original_path[source])
+                    else:
+                        fops.remove(source)
+
+            for slave in slaves:
+                if slave != source:
+                    if os.path.isfile(slave) or os.path.islink(slave):
+                        if os.path.realpath(slave) != master:
+                            fops.remove(slave)
+                        else:
+                            # already linked to master so just ignore
+                            continue
+                fops.link(master, slave)
+
+        return fops
+
+    def restore(self, files):
+        fops = FileOps(self.repo)
+
+        for path in files:
+            categories = files[path]
+            master = min(categories)
+            source = os.path.join(self.repo, master, path)
+
+            if not os.path.exists(source):
+                logging.debug(f'{source} not found in repo')
+                logging.warning(f'unable to find "{path}" in repo, skipping')
+                continue
+
+            dest = os.path.join(self.restore_path, path)
+
+            # Use shared conflict handling logic
+            # Import here to avoid circular imports
+            import sys
+            import os as os_module
+            # Get the repo root by going up from repo path
+            repo_root = os_module.path.dirname(os_module.path.dirname(self.repo))
+            
+            # Import handle_dest_file_conflict from __main__ if available
+            # For now, use inline simplified version that matches restore behavior
+            should_proceed, should_copy = self._handle_restore_conflict(source, dest)
+            
+            if not should_proceed:
+                continue
+            if not should_copy:
+                # Files are same, skip
+                continue
+
+            fops.plugin(self.plugin.remove, source, dest)
+
+        return fops
+    
+    def _handle_restore_conflict(self, source, dest):
+        """Handle conflict for restore operation (simpler than unmanage)"""
+        if not os.path.exists(dest):
+            # Check for dangling symlink
+            if os.path.islink(dest):
+                os.remove(dest)
+            return (True, True)
+        
+        # Check if files are the same
+        try:
+            if self.plugin.samefile(source, dest):
+                logging.debug(f'{dest} is the same file as in the repo, skipping')
+                return (True, False)  # Skip, don't copy
+        except Exception:
+            pass
+        
+        # Check if dest is a symlink to repo
+        if os.path.islink(dest):
+            link_target = os.readlink(dest)
+            repo_abs = os.path.abspath(source)
+            if os.path.abspath(link_target) == repo_abs or link_target.startswith(os.path.dirname(os.path.dirname(self.repo)) + os.sep):
+                # Symlink to repo, safe to remove
+                logging.info(f'{dest} already linked to repo, replacing with new file')
+                os.remove(dest)
+                return (True, True)
+            else:
+                # Symlink to somewhere else, ask user (restore behavior)
+                a = input(f'{dest} already exists, replace? [Yn] ')
+                a = 'y' if not a else a
+                if a.lower() == 'y':
+                    os.remove(dest)
+                    return (True, True)
+                else:
+                    return (False, False)  # Cancelled
+        
+        # Regular file exists - simple prompt for restore
+        a = input(f'{dest} already exists, replace? [Yn] ')
+        a = 'y' if not a else a
+        if a.lower() == 'y':
+            os.remove(dest)
+            return (True, True)
+        else:
+            return (False, False)  # Cancelled
+
+    # removes links from restore path that point to the repo
+    def clean(self, files):
+        fops = FileOps(self.repo)
+
+        for path in files:
+            categories = files[path]
+            master = min(categories)
+            repo_path = os.path.join(self.repo, master, path)
+
+            restore_path = os.path.join(self.restore_path, path)
+
+            if os.path.exists(repo_path) and os.path.exists(restore_path):
+                if self.plugin.samefile(repo_path, restore_path):
+                    fops.remove(restore_path)
+
+        return fops
+
+    # will go through the repo and search for files that should no longer be
+    # there. accepts a list of filenames that are allowed
+    def clean_repo(self, filenames):
+        fops = FileOps(self.repo)
+
+        if not os.path.isdir(self.repo):
+            return fops
+
+        # System files to ignore (e.g., macOS .DS_Store, Windows Thumbs.db)
+        SYSTEM_FILES = {'.DS_Store', 'Thumbs.db', '.DS_Store?'}
+
+        for category in os.listdir(self.repo):
+            # Skip system files
+            if category in SYSTEM_FILES:
+                continue
+
+            category_path = os.path.join(self.repo, category)
+
+            # Skip if not a directory (shouldn't happen, but be safe)
+            if not os.path.isdir(category_path):
+                continue
+
+            # remove empty category folders
+            try:
+                if not os.listdir(category_path):
+                    logging.info(f'{category} is empty, removing')
+                    fops.remove(category)
+                    continue
+            except (OSError, NotADirectoryError):
+                # If listdir fails, skip this entry
+                continue
+
+            for root, dirs, files in os.walk(category_path):
+                # Filter out system files from directories list
+                dirs[:] = [d for d in dirs if d not in SYSTEM_FILES]
+
+                # remove empty directories
+                for dname in dirs:
+                    dname = os.path.join(root, dname)
+                    if os.path.isdir(dname):
+                        try:
+                            if not os.listdir(dname):
+                                dname = os.path.relpath(dname, self.repo)
+                                logging.info(f'{dname} is empty, removing')
+                                fops.remove(dname)
+                        except (OSError, NotADirectoryError):
+                            continue
+
+                # remove files that are not in the manifest
+                for fname in files:
+                    # Skip system files
+                    if fname in SYSTEM_FILES:
+                        continue
+                    fname = os.path.relpath(os.path.join(root, fname),
+                                            self.repo)
+                    if fname not in filenames:
+                        logging.info(f'{fname} is not in the manifest, '
+                                     'removing')
+                        fops.remove(fname)
+
+        return fops
+
+    # goes through the filelist and finds files that have modifications that
+    # are not yet in the repo e.g. changes to encrypted files. This should not
+    # be used for any calculations, only for informational purposes
+    def diff(self, categories):
+        diffs = []
+        for category in categories:
+            category_path = os.path.join(self.repo, category)
+
+            for root, dirs, files in os.walk(category_path):
+                for fname in files:
+                    fname = os.path.join(root, fname)
+                    fname = os.path.relpath(fname, category_path)
+
+                    restore_file = os.path.join(self.restore_path, fname)
+                    category_file = os.path.join(category_path, fname)
+
+                    if not os.path.exists(restore_file):
+                        continue
+
+                    logging.debug(f'checking diff samefile for {restore_file}')
+                    if not self.plugin.samefile(category_file, restore_file):
+                        diffs.append(f'modified {restore_file}')
+
+        return diffs

dotsync/checks.py

@@ -0,0 +1,41 @@
+import os
+import logging
+import subprocess
+
+
+def safety_checks(dir_name, home, init):
+    # check that we're not in the user's home folder
+    if dir_name == home:
+        logging.error('dotsync should not be run inside home folder')
+        return False
+
+    try:
+        subprocess.run(['git', '--version'], check=True,
+                       stdout=subprocess.PIPE)
+    except FileNotFoundError:
+        logging.error('"git" command not found in path, needed for proper '
+                      'dotsync operation')
+        return False
+
+    if init:
+        return True
+
+    if os.path.isfile(os.path.join(dir_name, 'cryptlist')):
+        logging.error('this appears to be an old dotsync repo, please check '
+                      'the documentation for '
+                      'instructions on how to migrate your repo to the new '
+                      'version of dotsync or use the old version of dotsync by '
+                      'rather running "dotsync.sh"')
+        return False
+
+    if not os.path.isdir(os.path.join(dir_name, '.git')):
+        logging.error('this does not appear to be a git repo, make sure to '
+                      'init the repo before running dotsync in this folder')
+        return False
+
+    for flist in ['filelist']:
+        if not os.path.isfile(os.path.join(dir_name, flist)):
+            logging.error(f'unable to locate {flist} in repo')
+            return False
+
+    return True

dotsync/enums.py

@@ -0,0 +1,16 @@
+import enum
+
+
+class Actions(enum.Enum):
+    """Actions ordered by typical usage lifecycle"""
+    INIT = 'init'          # Initialize dotsync repository (first-time setup)
+    ADD = 'add'            # Add new config file to filelist
+    ENCRYPT = 'encrypt'    # Convert existing plain config to encrypted
+    UNMANAGE = 'unmanage'  # Restore file to home and stop managing it
+    LIST = 'list'          # List all managed configuration files
+    UPDATE = 'update'      # Sync config files from home to repository
+    RESTORE = 'restore'    # Restore config files from repository to home
+    DIFF = 'diff'          # Show differences between home and repository
+    COMMIT = 'commit'      # Commit changes to git and optionally push
+    CLEAN = 'clean'        # Remove files from repository that are no longer managed
+    PASSWD = 'passwd'      # Change encryption password for encrypted files

dotsync/file_ops.py

@@ -0,0 +1,122 @@
+import os
+import logging
+import enum
+import shutil
+import inspect
+
+
+class Op(enum.Enum):
+    LINK = enum.auto()
+    COPY = enum.auto()
+    MOVE = enum.auto()
+    REMOVE = enum.auto()
+    MKDIR = enum.auto()
+
+
+class FileOps:
+    def __init__(self, wd):
+        self.wd = wd
+        self.ops = []
+
+    def clear(self):
+        self.ops = []
+
+    def check_path(self, path):
+        return path if os.path.isabs(path) else os.path.join(self.wd, path)
+
+    def check_dest_dir(self, path):
+        dirname = os.path.dirname(path)
+        if not os.path.isdir(self.check_path(dirname)):
+            self.mkdir(dirname)
+
+    def mkdir(self, path):
+        logging.debug(f'adding mkdir op for {path}')
+        self.ops.append((Op.MKDIR, path))
+
+    def copy(self, source, dest):
+        logging.debug(f'adding cp op for {source} -> {dest}')
+        self.check_dest_dir(dest)
+        self.ops.append((Op.COPY, (source, dest)))
+
+    def move(self, source, dest):
+        logging.debug(f'adding mv op for {source} -> {dest}')
+        self.check_dest_dir(dest)
+        self.ops.append((Op.MOVE, (source, dest)))
+
+    def link(self, source, dest):
+        logging.debug(f'adding ln op for {source} <- {dest}')
+        self.check_dest_dir(dest)
+        self.ops.append((Op.LINK, (source, dest)))
+
+    def remove(self, path):
+        logging.debug(f'adding rm op for {path}')
+        self.ops.append((Op.REMOVE, path))
+
+    def plugin(self, plugin, source, dest):
+        logging.debug(f'adding plugin op ({plugin.__qualname__}) for {source} '
+                      f'-> {dest}')
+        self.check_dest_dir(dest)
+        self.ops.append((plugin, (source, dest)))
+
+    def apply(self, dry_run=False):
+        for op in self.ops:
+            op, path = op
+
+            if type(path) is tuple:
+                src, dest = path
+                src, dest = self.check_path(src), self.check_path(dest)
+                logging.info(self.str_op(op, (src, dest)))
+            else:
+                path = self.check_path(path)
+                logging.info(self.str_op(op, path))
+
+            if dry_run:
+                continue
+
+            if op == Op.LINK:
+                src = os.path.relpath(src, os.path.join(self.wd,
+                                                        os.path.dirname(dest)))
+                os.symlink(src, dest)
+            elif op == Op.COPY:
+                shutil.copyfile(src, dest)
+            elif op == Op.MOVE:
+                os.rename(src, dest)
+            elif op == Op.REMOVE:
+                if os.path.isdir(path):
+                    shutil.rmtree(path)
+                else:
+                    os.remove(path)
+            elif op == Op.MKDIR:
+                if not os.path.isdir(path):
+                    os.makedirs(path)
+            elif callable(op):
+                op(src, dest)
+
+        self.clear()
+
+    def append(self, other):
+        self.ops += other.ops
+        return self
+
+    def str_op(self, op, path):
+        def strip_wd(p):
+            p = str(p)
+            wd = str(self.wd)
+            return p[len(wd) + 1:] if p.startswith(wd) else p
+
+        if type(op) is Op:
+            op = op.name
+        else:
+            op = dict(inspect.getmembers(op))['__self__'].strify(op)
+
+        if type(path) is tuple:
+            path = [strip_wd(p) for p in path]
+            return f'{op} "{path[0]}" -> "{path[1]}"'
+        else:
+            return f'{op} "{strip_wd(path)}"'
+
+    def __str__(self):
+        return '\n'.join(self.str_op(*op) for op in self.ops)
+
+    def __repr__(self):
+        return str(self.ops)