Refactor taskipy into Task, PyProject, and TaskRunner (#15)

* Run `poetry update`

* Sort test imports & convert unused f strings to strings

There were some f strings that weren't interpolating anything.

* Create custom exceptions

* Refactor taskipi package into task, pyproject, and task_runner

* Add docstrings & types to task & task_runner.

Also, a small refactoring of __bail_on_first_fail()
in task_runner.py.

* Remove docstrings

* Add MissingTaskipySettingsSectionError

* Make path & items in PyProject private

* Check runner is string rather than catching AttributeError

* Add default exception case to cli

* Add exit_code class variable to exceptions

* Change PyProject to take in the file_path

This also converts the instance variables to be private
and has __load_toml_file convert the file_path to a Path
if it is a str. We also no longer store the file_path
since __load_toml_file is the only place it is needed
so it is just passed in.

* Task now builds the commands & takes in args + project

I think args could possibly be moved over to commands
since that is the only place it is used and that would
reduce the amount of things we are passing in to Task.
commands would just have to be converted to a method instead
of a property then.

* TaskRunner only runs the commands now with the project passed in

Instead of putting the commands together, that is now delegated
to Task. The run_commands_and_bail_on_first_fail method is now
gone as that is what `run` does now. Furthermore, the instance
variables of TaskRunner are private now. A single instance of the
TaskRunner can now run many tasks now, since it is not tied to
any particular task.

* Update cli to use updated TaskRunner

The pyproject.toml path is now passed in
with the command name and args being passed
to `run`.

* Use single quotes

* Extract pre_task & post_task to use __find_hooks

They are basically the same method, with a one word
difference.

Author: eugenetriguba

.hooks/make_release_commit.py

@@ -1,16 +1,16 @@
 #!/usr/bin/env python3
 import toml
 import subprocess
-import os
-from os import path
+from pathlib import Path
 
 def create_release_commit():
-    pyproject = toml.load(path.join(os.curdir, 'pyproject.toml'))
+    cwd = Path.cwd()
+    pyproject = toml.load(cwd / 'pyproject.toml')
     version = pyproject['tool']['poetry']['version']
 
     p = subprocess.Popen(f'git add . && git commit -m "Release version {version}" && git tag -a "{version}" -m "Release version {version}" && git push && git push --tags',
                          shell=True,
-                         cwd=os.curdir)
+                         cwd=cwd)
 
     p.wait()
 

.pylintrc

@@ -5,7 +5,8 @@ disable=
       W0702,
       C0411,
       R0903,
-      R0915
+      R0915,
+      W0703
 
 [FORMAT]
 max-line-length=1000

poetry.lock

@@ -1,14 +1,33 @@
 #!/usr/bin/env python3
 import argparse
-from taskipy.run import run_task
+import sys
+from pathlib import Path
+
+from taskipy.exceptions import TaskipyError
+from taskipy.task_runner import TaskRunner
+
 
 def main():
-    parser = argparse.ArgumentParser(prog='task', description='runs a task specified in your pyproject.toml under [tool.taskipy.tasks]')
+    parser = argparse.ArgumentParser(
+        prog='task',
+        description='runs a task specified in your pyproject.toml under [tool.taskipy.tasks]',
+    )
     parser.add_argument('name', help='name of the task')
-    parser.add_argument('args', nargs=argparse.REMAINDER, help='arguments to pass to the task')
+    parser.add_argument(
+        'args', nargs=argparse.REMAINDER, help='arguments to pass to the task'
+    )
     args = parser.parse_args()
 
-    run_task(args.name, args.args)
+    try:
+        exit_code = TaskRunner(Path.cwd() / 'pyproject.toml').run(args.name, args.args)
+        sys.exit(exit_code)
+    except TaskipyError as e:
+        print(e)
+        sys.exit(e.exit_code)
+    except Exception as e:
+        print(e)
+        sys.exit(1)
+
 
 if __name__ == '__main__':
     main()

taskipy/cli.py

@@ -0,0 +1,51 @@
+class TaskipyError(Exception):
+    exit_code = 1
+
+
+class InvalidRunnerTypeError(TaskipyError):
+    def __str__(self):
+        return (
+            'invalid value: runner is not a string. '
+            'please check [tool.taskipy.settings.runner]'
+        )
+
+
+class MissingPyProjectFileError(TaskipyError):
+    def __str__(self):
+        return 'no pyproject.toml file found in this directory'
+
+
+class MalformedPyProjectError(TaskipyError):
+    def __str__(self):
+        return 'pyproject.toml file is malformed and could not be read'
+
+
+class TaskNotFoundError(TaskipyError):
+    exit_code = 127
+
+    def __init__(self, task_name: str):
+        super().__init__()
+        self.task = task_name
+
+    def __str__(self):
+        return f'could not find task "{self.task}"'
+
+
+class MissingTaskipySettingsSectionError(TaskipyError):
+    exit_code = 127
+
+    def __str__(self):
+        return (
+            'no settings found. add a [tools.taskipy.settings]'
+            'section to your pyproject.toml'
+        )
+
+
+class MissingTaskipyTasksSectionError(TaskipyError):
+    exit_code = 127
+
+    def __str__(self):
+        return (
+            'no tasks found. add a [tool.taskipy.tasks] '
+            'section to your pyproject.toml'
+        )

taskipy/exceptions.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+from typing import Any, MutableMapping, Union
+
+import toml
+
+from taskipy.exceptions import (
+    MalformedPyProjectError,
+    MissingPyProjectFileError,
+    MissingTaskipyTasksSectionError,
+    MissingTaskipySettingsSectionError
+)
+
+
+class PyProject:
+    def __init__(self, file_path: Union[str, Path]):
+        self.__items = PyProject.__load_toml_file(file_path)
+
+    @property
+    def tasks(self) -> dict:
+        try:
+            return self.__items['tool']['taskipy']['tasks']
+        except KeyError:
+            raise MissingTaskipyTasksSectionError()
+
+    @property
+    def settings(self) -> dict:
+        try:
+            return self.__items['tool']['taskipy']['settings']
+        except KeyError:
+            raise MissingTaskipySettingsSectionError()
+
+    @staticmethod
+    def __load_toml_file(file_path: Union[str, Path]) -> MutableMapping[str, Any]:
+        try:
+            if isinstance(file_path, str):
+                file_path = Path(file_path).resolve()
+
+            return toml.load(file_path)
+        except FileNotFoundError:
+            raise MissingPyProjectFileError()
+        except toml.TomlDecodeError:
+            raise MalformedPyProjectError()