aboutsummaryrefslogtreecommitdiffstats
path: root/task
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--taskipy/exceptions.py9
-rw-r--r--taskipy/help.py33
-rw-r--r--taskipy/pyproject.py26
-rw-r--r--taskipy/task.py85
-rw-r--r--taskipy/task_runner.py118
5 files changed, 172 insertions, 99 deletions
diff --git a/taskipy/exceptions.py b/taskipy/exceptions.py
index 16d1e58..573967e 100644
--- a/taskipy/exceptions.py
+++ b/taskipy/exceptions.py
@@ -32,6 +32,15 @@ class TaskNotFoundError(TaskipyError):
def __str__(self):
return f'could not find task "{self.task}"'
+class MalformedTaskError(TaskipyError):
+ def __init__(self, task_name: str, reason: str):
+ super().__init__()
+ self.task = task_name
+ self.reason = reason
+
+ def __str__(self):
+ return f'the task "{self.task}" in the pyproject.toml file is malformed. reason: {self.reason}'
+
class InvalidUsageError(TaskipyError):
exit_code = 127
diff --git a/taskipy/help.py b/taskipy/help.py
new file mode 100644
index 0000000..77e3645
--- /dev/null
+++ b/taskipy/help.py
@@ -0,0 +1,33 @@
+import shutil
+import textwrap
+import colorama # type: ignore
+from typing import List
+
+from taskipy.task import Task
+
+
+class HelpFormatter:
+ def __init__(self, tasks: List[Task]):
+ self.__tasks = tasks
+
+ def print(self, line_width=shutil.get_terminal_size().columns):
+ colorama.init()
+
+ tasks_col = [task.name for task in self.__tasks]
+ longest_item_in_tasks_col = len(max(tasks_col, key=len))
+
+ desc_col_wrap_indent = ' ' * (longest_item_in_tasks_col + 1)
+ desc_col_width = line_width - len(desc_col_wrap_indent)
+
+ for task in self.__tasks:
+ name_text = task.name
+ desc_text = task.description or task.command
+
+ tasks_col_text = f'{name_text:<{longest_item_in_tasks_col}}'
+ desc_col_text = '\n'.join(textwrap.wrap(desc_text,
+ width=desc_col_width,
+ subsequent_indent=desc_col_wrap_indent))
+ print(f'{self.__highlight(tasks_col_text)} {desc_col_text}')
+
+ def __highlight(self, text: str):
+ return f'{colorama.Fore.CYAN}{text}{colorama.Style.RESET_ALL}'
diff --git a/taskipy/pyproject.py b/taskipy/pyproject.py
index 4bb599b..8486cb6 100644
--- a/taskipy/pyproject.py
+++ b/taskipy/pyproject.py
@@ -1,9 +1,11 @@
-from pathlib import Path
-from typing import Any, MutableMapping, Union
-
import toml
+from pathlib import Path
+from typing import Any, Dict, MutableMapping, Optional, Union
+
+from taskipy.task import Task
from taskipy.exceptions import (
+ InvalidRunnerTypeError,
MalformedPyProjectError,
MissingPyProjectFileError,
MissingTaskipyTasksSectionError,
@@ -17,9 +19,11 @@ class PyProject:
self.__items = PyProject.__load_toml_file(pyproject_path)
@property
- def tasks(self) -> dict:
+ def tasks(self) -> Dict[str, Task]:
try:
- return self.__items['tool']['taskipy']['tasks']
+ return {
+ task_name: Task(task_name, task_toml_contents) for
+ task_name, task_toml_contents in self.__items['tool']['taskipy']['tasks'].items() }
except KeyError:
raise MissingTaskipyTasksSectionError()
@@ -30,6 +34,18 @@ class PyProject:
except KeyError:
raise MissingTaskipySettingsSectionError()
+ @property
+ def runner(self) -> Optional[str]:
+ try:
+ runner = self.settings['runner']
+
+ if not isinstance(runner, str):
+ raise InvalidRunnerTypeError()
+
+ return runner.strip()
+ except (KeyError, MissingTaskipySettingsSectionError):
+ return None
+
@staticmethod
def __load_toml_file(file_path: Union[str, Path]) -> MutableMapping[str, Any]:
try:
diff --git a/taskipy/task.py b/taskipy/task.py
index 05e6329..c357b98 100644
--- a/taskipy/task.py
+++ b/taskipy/task.py
@@ -1,71 +1,44 @@
-import platform
-import shlex
-import mslex # type: ignore
-from typing import Optional, List
-
-from taskipy.exceptions import (
- InvalidRunnerTypeError,
- TaskNotFoundError,
- MissingTaskipySettingsSectionError
-)
-from taskipy.pyproject import PyProject
+from taskipy.exceptions import MalformedTaskError
class Task:
- def __init__(self, task_name: str, args: List[str], project: PyProject):
- self.project = project
- self.name = task_name
- self.args = args
-
- def __str__(self) -> str:
- return self.name
+ def __init__(self, task_name: str, task_toml_contents: object):
+ self.__task_name = task_name
+ self.__task_command = self.__extract_task_command(task_toml_contents)
+ self.__task_description = self.__extract_task_description(task_toml_contents)
@property
- def pre_task(self) -> Optional[str]:
- return self.__find_hooks('pre')
+ def name(self):
+ return self.__task_name
@property
- def post_task(self) -> Optional[str]:
- return self.__find_hooks('post')
+ def command(self):
+ return self.__task_command
@property
- def commands(self) -> List[str]:
- try:
- command = self.project.tasks[self.name]
- commands = []
- commands.append(
- ' '.join([command] + [self.__quote_arg(arg) for arg in self.args])
- )
-
- if self.pre_task:
- commands.insert(0, self.pre_task)
+ def description(self):
+ return self.__task_description
- if self.post_task:
- commands.append(self.post_task)
+ def __extract_task_command(self, task_toml_contents: object) -> str:
+ if isinstance(task_toml_contents, str):
+ return task_toml_contents
- return commands
- except KeyError:
- raise TaskNotFoundError(self.name)
-
- @property
- def runner(self) -> Optional[str]:
- try:
- runner = self.project.settings['runner']
+ if isinstance(task_toml_contents, dict):
+ try:
+ return task_toml_contents['cmd']
+ except KeyError:
+ raise MalformedTaskError(self.__task_name, 'the task item does not have the "cmd" property')
- if not isinstance(runner, str):
- raise InvalidRunnerTypeError()
+ raise MalformedTaskError(self.__task_name, 'tasks must be strings, or dicts that contain { cmd, help }')
- return runner.strip()
- except (KeyError, MissingTaskipySettingsSectionError):
- return None
+ def __extract_task_description(self, task_toml_contents: object) -> str:
+ if isinstance(task_toml_contents, str):
+ return ''
- def __find_hooks(self, hook_type: str) -> Optional[str]:
- try:
- return self.project.tasks[f'{hook_type}_{self.name}']
- except KeyError:
- return None
+ if isinstance(task_toml_contents, dict):
+ try:
+ return task_toml_contents['help']
+ except KeyError:
+ return ''
- def __quote_arg(self, arg: str) -> str:
- if platform.system() == 'Windows':
- return mslex.quote(arg)
- return shlex.quote(arg)
+ raise MalformedTaskError(self.__task_name, 'tasks must be strings, or dicts that contain { cmd, help }')
diff --git a/taskipy/task_runner.py b/taskipy/task_runner.py
index 444adbd..0aa3aa1 100644
--- a/taskipy/task_runner.py
+++ b/taskipy/task_runner.py
@@ -1,59 +1,101 @@
import sys
-
+import platform
import psutil # type: ignore
import signal
import subprocess
+import shlex
+import mslex # type: ignore
from pathlib import Path
-from typing import List, Union
+from typing import List, Union, Optional
from taskipy.pyproject import PyProject
+from taskipy.exceptions import TaskNotFoundError
from taskipy.task import Task
+from taskipy.help import HelpFormatter
class TaskRunner:
def __init__(self, cwd: Union[str, Path]):
working_dir = cwd if isinstance(cwd, Path) else Path(cwd)
self.__working_dir = working_dir
- self.project = PyProject(working_dir)
+ self.__project = PyProject(working_dir)
def list(self):
"""lists tasks to stdout"""
- longest = len(max(self.project.tasks, key=len))
- for k, v in self.project.tasks.items():
- print(f'{k:<{longest}} {v}')
+ formatter = HelpFormatter(self.__project.tasks.values())
+ formatter.print()
def run(self, task_name: str, args: List[str]) -> int:
- task = Task(task_name, args, self.project)
-
- for command in task.commands:
- if task.runner is not None:
- command = f'{task.runner} {command}'
- process = subprocess.Popen(
- command, shell=True, cwd=self.__working_dir
- )
-
- def send_signal_to_task_process(signum: int, frame) -> None: # pylint: disable=unused-argument
- # pylint: disable=W0640
- psutil_process_wrapper = psutil.Process(process.pid)
- is_direct_subprocess_a_shell_process = sys.platform != 'darwin' # pylint: disable=C0103
-
- if is_direct_subprocess_a_shell_process:
- # A shell is created because of Popen(..., shell=True) on linux only
- # We want here to kill shell's child
- sub_processes_of_taskipy_shell = psutil_process_wrapper.children()
- for child_process in sub_processes_of_taskipy_shell:
- child_process.send_signal(signum)
- else:
- process.send_signal(signum)
-
- signal.signal(signal.SIGTERM, send_signal_to_task_process)
-
- try:
- process.wait()
- except KeyboardInterrupt:
- pass
-
- if process.returncode != 0:
- return process.returncode
+ try:
+ task = self.__project.tasks[task_name]
+ except KeyError:
+ raise TaskNotFoundError(task_name)
+
+ pre_task = self.__pre_task(task_name)
+ if pre_task is not None:
+ exit_code = self.__run_command_and_return_exit_code(pre_task.command)
+ if exit_code != 0:
+ return exit_code
+
+ exit_code = self.__run_command_and_return_exit_code(task.command, args)
+ if exit_code != 0:
+ return exit_code
+
+ post_task = self.__post_task(task_name)
+ if post_task is not None:
+ exit_code = self.__run_command_and_return_exit_code(post_task.command)
+ if exit_code != 0:
+ return exit_code
return 0
+
+ def __run_command_and_return_exit_code(self, command: str, args: List[str] = None) -> int:
+ if args is None:
+ args = []
+
+ if self.__project.runner is not None:
+ command = f'{self.__project.runner} {command}'
+
+ def quote_arg(arg: str) -> str:
+ if platform.system() == 'Windows':
+ return mslex.quote(arg)
+ return shlex.quote(arg)
+
+ def send_signal_to_task_process(signum: int, _frame) -> None:
+ # pylint: disable=W0640
+ psutil_process_wrapper = psutil.Process(process.pid)
+ is_direct_subprocess_a_shell_process = sys.platform != 'darwin' # pylint: disable=C0103
+
+ if is_direct_subprocess_a_shell_process:
+ # A shell is created because of Popen(..., shell=True) on linux only
+ # We want here to kill shell's child
+ sub_processes_of_taskipy_shell = psutil_process_wrapper.children()
+ for child_process in sub_processes_of_taskipy_shell:
+ child_process.send_signal(signum)
+ else:
+ process.send_signal(signum)
+
+ command_with_args = ' '.join([command] + [quote_arg(arg) for arg in args])
+ process = subprocess.Popen(command_with_args,
+ shell=True,
+ cwd=self.__working_dir)
+ signal.signal(signal.SIGTERM, send_signal_to_task_process)
+
+ try:
+ process.wait()
+ except KeyboardInterrupt:
+ pass
+
+ return process.returncode
+
+ def __pre_task(self, task_name: str):
+ return self.__find_hooks('pre', task_name)
+
+ def __post_task(self, task_name: str):
+ return self.__find_hooks('post', task_name)
+
+ def __find_hooks(self, hook_type: str, task_name: str) -> Optional[Task]:
+ try:
+ return self.__project.tasks[f'{hook_type}_{task_name}']
+ except KeyError:
+ return None