dploy 0.1.3__py3-none-any.whl

dploy/__init__.py

@@ -0,0 +1,35 @@
+"""
+dploy script is an attempt at creating a clone of GNU stow that will work on
+Windows as well as *nix
+"""
+
+from dploy import linkcmd
+from dploy import stowcmd
+
+
+def stow(sources, dest, is_silent=True, is_dry_run=False, ignore_patterns=None):
+    """
+    sub command stow
+    """
+    stowcmd.Stow(sources, dest, is_silent, is_dry_run, ignore_patterns)
+
+
+def unstow(sources, dest, is_silent=True, is_dry_run=False, ignore_patterns=None):
+    """
+    sub command unstow
+    """
+    stowcmd.UnStow(sources, dest, is_silent, is_dry_run, ignore_patterns)
+
+
+def clean(sources, dest, is_silent=True, is_dry_run=False, ignore_patterns=None):
+    """
+    sub command clean
+    """
+    stowcmd.Clean(sources, dest, is_silent, is_dry_run, ignore_patterns)
+
+
+def link(source, dest, is_silent=True, is_dry_run=False, ignore_patterns=None):
+    """
+    sub command link
+    """
+    linkcmd.Link(source, dest, is_silent, is_dry_run, ignore_patterns)

dploy/__main__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+"""
+The entry point when dploy is called as a module
+"""
+
+from dploy import cli
+
+
+def main():
+    """
+    main entry point when using dploy from the command line
+    """
+    cli.run()
+
+
+if __name__ == "__main__":
+    main()

dploy/actions.py

@@ -0,0 +1,217 @@
+"""
+This module contains the actions that are combined to perform dploy's sub
+commands
+"""
+
+from collections import defaultdict
+from dploy import utils
+
+
+class Actions:
+    """
+    A class that collects and executes action objects
+    """
+
+    def __init__(self, is_silent, is_dry_run):
+        self.actions = []
+        self.is_silent = is_silent
+        self.is_dry_run = is_dry_run
+
+    def add(self, action):
+        """
+        Adds an action
+        """
+        self.actions.append(action)
+
+    def execute(self):
+        """
+        Prints and executes actions
+        """
+        for action in self.actions:
+            if not self.is_silent:
+                print(action)
+            if not self.is_dry_run:
+                action.execute()
+
+    def get_unlink_actions(self):
+        """
+        get the current Unlink() actions from the self.actions
+        """
+        return [a for a in self.actions if isinstance(a, UnLink)]
+
+    def get_unlink_target_parents(self):
+        """
+        Get list of the parents for the current Unlink() actions from
+        self.actions
+        """
+        unlink_actions = self.get_unlink_actions()
+        # sort for deterministic output
+        return sorted(set([a.target.parent for a in unlink_actions]))
+
+    def get_unlink_targets(self):
+        """
+        Get list of the targets for the current Unlink() actions from
+        self.actions
+        """
+        unlink_actions = self.get_unlink_actions()
+        return [a.target for a in unlink_actions]
+
+    def get_duplicates(self):
+        """
+        return a tuple containing tuples with the following structure
+        (link destination, [indices of duplicates])
+        """
+        tally = defaultdict(list)
+        for index, action in enumerate(self.actions):
+            if isinstance(action, SymbolicLink):
+                tally[action.dest].append(index)
+        # sort for deterministic output
+        return sorted([indices for _, indices in tally.items() if len(indices) > 1])
+
+
+class AbstractBaseAction:
+    # pylint: disable=too-few-public-methods
+    """
+    An abstract base class that define the interface for actions
+    """
+
+    def __init__(self):
+        pass
+
+    def execute(self):
+        """
+        function that executes the logic of each concrete action
+        """
+        pass
+
+
+class SymbolicLink(AbstractBaseAction):
+    # pylint: disable=too-few-public-methods
+    """
+    Action to create a symbolic link relative to the source of the link
+    """
+
+    def __init__(self, subcmd, source, dest):
+        super().__init__()
+        self.source = source
+        self.source_relative = utils.get_relative_path(source, dest.parent)
+        self.subcmd = subcmd
+        self.dest = dest
+
+    def execute(self):
+        self.dest.symlink_to(self.source_relative)
+
+    def __repr__(self):
+        return "dploy {subcmd}: link {dest} => {source}".format(
+            subcmd=self.subcmd, dest=self.dest, source=self.source_relative
+        )
+
+
+class AlreadyLinked(AbstractBaseAction):
+    # pylint: disable=too-few-public-methods
+    """
+    Action to used to print an already linked message
+    """
+
+    def __init__(self, subcmd, source, dest):
+        super().__init__()
+        self.source = source
+        self.source_relative = utils.get_relative_path(source, dest.parent)
+        self.dest = dest
+        self.subcmd = subcmd
+
+    def execute(self):
+        pass
+
+    def __repr__(self):
+        return "dploy {subcmd}: already linked {dest} => {source}".format(
+            subcmd=self.subcmd, source=self.source_relative, dest=self.dest
+        )
+
+
+class AlreadyUnlinked(AbstractBaseAction):
+    # pylint: disable=too-few-public-methods
+    """
+    Action to used to print an already unlinked message
+    """
+
+    def __init__(self, subcmd, source, dest):
+        super().__init__()
+        self.source = source
+        self.source_relative = utils.get_relative_path(source, dest.parent)
+        self.dest = dest
+        self.subcmd = subcmd
+
+    def execute(self):
+        pass
+
+    def __repr__(self):
+        return "dploy {subcmd}: already unlinked {dest} => {source}".format(
+            subcmd=self.subcmd, source=self.source_relative, dest=self.dest
+        )
+
+
+class UnLink(AbstractBaseAction):
+    # pylint: disable=too-few-public-methods
+    """
+    Action to unlink a symbolic link
+    """
+
+    def __init__(self, subcmd, target):
+        super().__init__()
+        self.target = target
+        self.subcmd = subcmd
+
+    def execute(self):
+        if not self.target.is_symlink():
+            # pylint: disable=line-too-long
+            raise RuntimeError(
+                "dploy detected and aborted an attempt to unlink a non-symlink {target} this is a bug and should be reported".format(
+                    target=self.target
+                )
+            )
+        self.target.unlink()
+
+    def __repr__(self):
+        return "dploy {subcmd}: unlink {target} => {source}".format(
+            subcmd=self.subcmd, target=self.target, source=utils.readlink(self.target)
+        )
+
+
+class MakeDirectory(AbstractBaseAction):
+    # pylint: disable=too-few-public-methods
+    """
+    Action to create a directory
+    """
+
+    def __init__(self, subcmd, target):
+        super().__init__()
+        self.target = target
+        self.subcmd = subcmd
+
+    def execute(self):
+        self.target.mkdir()
+
+    def __repr__(self):
+        return "dploy {subcmd}: make directory {target}".format(
+            target=self.target, subcmd=self.subcmd
+        )
+
+
+class RemoveDirectory(AbstractBaseAction):
+    # pylint: disable=too-few-public-methods
+    """
+    Action to remove a directory
+    """
+
+    def __init__(self, subcmd, target):
+        super().__init__()
+        self.target = target
+        self.subcmd = subcmd
+
+    def execute(self):
+        self.target.rmdir()
+
+    def __repr__(self):
+        msg = "dploy {subcmd}: remove directory {target}"
+        return msg.format(target=self.target, subcmd=self.subcmd)

dploy/cli.py

@@ -0,0 +1,114 @@
+"""
+The command line interface
+"""
+
+import sys
+import argparse
+from dploy import linkcmd
+from dploy import stowcmd
+from dploy import version
+from dploy.error import DployError
+
+
+def add_ignore_argument(parser):
+    """
+    adds the ignore argument to a subcmd parser
+    """
+    parser.add_argument(
+        "--ignore",
+        dest="ignore_patterns",
+        action="append",
+        default=None,
+        help="glob pattern used to ignore directories",
+    )
+
+
+def create_parser():
+    """
+    create the CLI argument parser
+    """
+    parser = argparse.ArgumentParser(prog="dploy")
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s {version}".format(version=version.__version__),
+    )
+    parser.add_argument(
+        "--silent", dest="is_silent", action="store_true", help="suppress all output"
+    )
+    parser.add_argument(
+        "--dry-run",
+        dest="is_dry_run",
+        action="store_true",
+        help="show what would be done without doing it",
+    )
+
+    sub_parsers = parser.add_subparsers(dest="subcmd")
+
+    stow_parser = sub_parsers.add_parser("stow")
+    stow_parser.add_argument("source", nargs="+", help="source directory to stow")
+    stow_parser.add_argument("dest", help="destination path to stow into")
+    add_ignore_argument(stow_parser)
+
+    unstow_parser = sub_parsers.add_parser("unstow")
+    unstow_parser.add_argument(
+        "source", nargs="+", help="source directory to unstow from"
+    )
+    unstow_parser.add_argument("dest", help="destination path to unstow")
+    add_ignore_argument(unstow_parser)
+
+    clean_parser = sub_parsers.add_parser("clean")
+    clean_parser.add_argument(
+        "source", nargs="+", help="source directory to clean from"
+    )
+    clean_parser.add_argument("dest", help="destination path to clean")
+    add_ignore_argument(clean_parser)
+
+    link_parser = sub_parsers.add_parser("link")
+    link_parser.add_argument("source", help="source file or directory to link")
+    link_parser.add_argument("dest", help="destination path to link")
+    add_ignore_argument(link_parser)
+    return parser
+
+
+def run(arguments=None):
+    """
+    interpret the parser arguments and execute the corresponding commands
+    """
+
+    subcmd_map = {
+        "stow": stowcmd.Stow,
+        "unstow": stowcmd.UnStow,
+        "clean": stowcmd.Clean,
+        "link": linkcmd.Link,
+    }
+
+    try:
+        parser = create_parser()
+
+        if arguments is None:
+            args = parser.parse_args()
+        else:
+            args = parser.parse_args(arguments)
+
+        if args.subcmd in subcmd_map:
+            subcmd = subcmd_map[args.subcmd]
+        else:
+            parser.print_help()
+            sys.exit(0)
+
+        try:
+            subcmd(
+                args.source,
+                args.dest,
+                is_silent=args.is_silent,
+                is_dry_run=args.is_dry_run,
+                ignore_patterns=args.ignore_patterns,
+            )
+        except DployError:
+            sys.exit(1)
+
+    except (KeyboardInterrupt) as error:
+        print(error, file=sys.stderr)
+        sys.exit(130)

dploy/error.py

@@ -0,0 +1,163 @@
+"""
+All the exceptions and their messages used by the program
+"""
+import sys
+
+ERROR_HEAD = "dploy {subcmd}: can not {subcmd} "
+
+
+class Errors:
+    """
+    A class that collects and executes action objects
+    """
+
+    def __init__(self, is_silent):
+        self.exceptions = []
+        self.is_silent = is_silent
+
+    def add(self, error):
+        """
+        Adds an error
+        """
+        self.exceptions.append(error)
+
+    def handle(self):
+        """
+        Prints and handles errors
+        """
+        if len(self.exceptions) > 0:
+            if not self.is_silent:
+                for exception in self.exceptions:
+                    print(exception, file=sys.stderr)
+            raise self.exceptions[0]
+
+
+# pylint: disable=missing-docstring
+# pylint: disable=too-few-public-methods
+
+
+class DployError(Exception):
+    pass
+
+
+class SourceIsSameAsDest(DployError):
+    def __init__(self, subcmd, file):
+        self.msg = (
+            ERROR_HEAD + "'{file}': A source argument is the same as the dest argument"
+        )
+        self.msg = self.msg.format(subcmd=subcmd, file=file)
+        # self.exception = ValueError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class ConflictsWithAnotherSource(DployError):
+    def __init__(self, subcmd, files):
+        self.msg = ERROR_HEAD + "the following: Conflicts with other source {files}"
+        files_list = "\n    " + "\n    ".join(files)
+        self.msg = self.msg.format(subcmd=subcmd, files=files_list)
+        # self.exception = ValueError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class ConflictsWithExistingFile(DployError):
+    def __init__(self, subcmd, source, dest):
+        self.msg = ERROR_HEAD + "'{source}': Conflicts with existing file '{dest}'"
+        self.msg = self.msg.format(subcmd=subcmd, source=source, dest=dest)
+        # self.exception = ValueError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class ConflictsWithExistingLink(DployError):
+    def __init__(self, subcmd, source, dest):
+        self.msg = ERROR_HEAD + "'{source}': Conflicts with existing symlink '{dest}'"
+        self.msg = self.msg.format(subcmd=subcmd, source=source, dest=dest)
+        # self.exception = ValueError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class InsufficientPermissions(DployError):
+    def __init__(self, subcmd, file):
+        self.msg = ERROR_HEAD + "'{file}': Insufficient permissions"
+        self.msg = self.msg.format(subcmd=subcmd, file=file)
+        # self.exception = PermissionError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class NoSuchDirectory(DployError):
+    def __init__(self, subcmd, file):
+        self.msg = ERROR_HEAD + "'{file}': No such directory"
+        self.msg = self.msg.format(subcmd=subcmd, file=file)
+        # self.exception = NotADirectoryError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class PermissionDenied(DployError):
+    def __init__(self, subcmd, file):
+        self.msg = ERROR_HEAD + "'{file}': Permission denied"
+        self.msg = self.msg.format(subcmd=subcmd, file=file)
+        # self.exception = PermissionError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class InsufficientPermissionsToSubcmdFrom(DployError):
+    def __init__(self, subcmd, file):
+        self.msg = ERROR_HEAD + "from '{file}': Insufficient permissions"
+        self.msg = self.msg.format(subcmd=subcmd, file=file)
+        # self.exception = PermissionError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class NoSuchDirectoryToSubcmdInto(DployError):
+    def __init__(self, subcmd, file):
+        self.msg = ERROR_HEAD + "into '{file}': No such directory"
+        self.msg = self.msg.format(subcmd=subcmd, file=file)
+        # self.exception = NotADirectoryError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class InsufficientPermissionsToSubcmdTo(DployError):
+    def __init__(self, subcmd, file):
+        self.msg = ERROR_HEAD + "to '{file}': Insufficient permissions"
+        self.msg = self.msg.format(subcmd=subcmd, file=file)
+        # self.exception = PermissionError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class NoSuchFileOrDirectory(DployError):
+    def __init__(self, subcmd, file):
+        self.msg = ERROR_HEAD + "'{file}': No such file or directory"
+        self.msg = self.msg.format(subcmd=subcmd, file=file)
+        # self.exception = FileNotFoundError(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class DuplicateSource(DployError):
+    def __init__(self, subcmd, file):
+        self.msg = ERROR_HEAD + "'{file}': Duplicate source argument"
+        self.msg = self.msg.format(subcmd=subcmd, file=file)
+        # self.exception = ValueError(self.msg)
+
+    def __str__(self):
+        return self.msg

dploy/ignore.py

@@ -0,0 +1,67 @@
+"""
+Module for the --ignore IGNORE_PATTERN flag and .dploystowignore file
+"""
+import pathlib
+from dploy import utils
+
+
+class Ignore:
+    """
+    Handles ignoring of files via glob patterns either passed in directly in or
+    in a specified ignore file.
+    """
+
+    def __init__(self, patterns, source):
+        if patterns is None:
+            input_patterns = []
+        else:
+            input_patterns = patterns
+        self.ignored_files = []
+
+        file = source.parent / pathlib.Path(".dploystowignore")
+
+        self.patterns = [str(file.name)]  # ignore the ignore file
+        self.patterns.extend(input_patterns)
+        self._read_ignore_file_patterns(file)
+
+    def _read_ignore_file_patterns(self, file):
+        """
+        read ignore patterns from a specified file
+        """
+        try:
+            with open(str(file)) as afile:
+                file_patterns = afile.read().splitlines()
+                self.patterns.extend(file_patterns)
+        except FileNotFoundError:
+            pass
+
+    def should_ignore(self, source):
+        """
+        check if a source should be ignored, based on the ignore patterns in
+        self.patterns
+
+        This checks if the ignore patterns match either the file exactly or
+        its parents
+        """
+        for pattern in self.patterns:
+            try:
+                files = sorted(source.parent.glob(pattern))
+            except IndexError:  # the glob result was empty
+                continue
+
+            for file in files:
+                if utils.is_same_file(file, source) or source in file.parents:
+                    return True
+        return False
+
+    def ignore(self, file):
+        """
+        add a file to be ignored
+        """
+        self.ignored_files.append(file)
+
+    def get_ignored_files(self):
+        """
+        get a list of the files that have been ignored
+        """
+        return self.ignored_files

dploy/linkcmd.py

@@ -0,0 +1,81 @@
+"""
+The logic and workings behind the link sub-commands
+"""
+
+from dploy import actions
+from dploy import utils
+from dploy import error
+from dploy import main
+
+
+# pylint: disable=too-few-public-methods
+class Link(main.AbstractBaseSubCommand):
+    """
+    Concrete class implementation of the link sub-command
+    """
+
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self, source, dest, is_silent=True, is_dry_run=False, ignore_patterns=None
+    ):
+        super().__init__("link", [source], dest, is_silent, is_dry_run, ignore_patterns)
+
+    def _is_valid_input(self, sources, dest):
+        """
+        Check to see if the input is valid
+        """
+        return LinkInput(self.errors, self.subcmd).is_valid(sources, dest)
+
+    def _collect_actions(self, source, dest):
+        """
+        Concrete method to collect required actions to perform a link
+        sub-command
+        """
+
+        if dest.exists():
+            if utils.is_same_file(dest, source):
+                self.actions.add(actions.AlreadyLinked(self.subcmd, source, dest))
+            else:
+                self.errors.add(
+                    error.ConflictsWithExistingFile(self.subcmd, source, dest)
+                )
+        elif dest.is_symlink():
+            self.errors.add(error.ConflictsWithExistingLink(self.subcmd, source, dest))
+
+        elif not dest.parent.exists():
+            self.errors.add(error.NoSuchDirectoryToSubcmdInto(self.subcmd, dest.parent))
+
+        else:
+            self.actions.add(actions.SymbolicLink(self.subcmd, source, dest))
+
+
+class LinkInput(main.Input):
+    """
+    Input validator for the link command
+    """
+
+    def _is_valid_dest(self, dest):
+        if not dest.parent.exists():
+            self.errors.add(error.NoSuchFileOrDirectory(self.subcmd, dest.parent))
+            return False
+
+        elif not utils.is_file_writable(dest.parent) or not utils.is_directory_writable(
+            dest.parent
+        ):
+            self.errors.add(error.InsufficientPermissionsToSubcmdTo(self.subcmd, dest))
+            return False
+
+        return True
+
+    def _is_valid_source(self, source):
+        if not source.exists():
+            self.errors.add(error.NoSuchFileOrDirectory(self.subcmd, source))
+            return False
+
+        elif not utils.is_file_readable(source) or not utils.is_directory_readable(
+            source
+        ):
+            self.errors.add(error.InsufficientPermissions(self.subcmd, source))
+            return False
+
+        return True