cook-build 0.6.3__tar.gz → 0.6.4__tar.gz

{cook_build-0.6.3/src/cook_build.egg-info → cook_build-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cook-build
-Version: 0.6.3
+Version: 0.6.4
 Summary: A task-centric build system with simple declarative recipes specified in Python
 Author: Till Hoffmann
 License: BSD-3-Clause

{cook_build-0.6.3 → cook_build-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cook-build"
-version = "0.6.3"
+version = "0.6.4"
 description = "A task-centric build system with simple declarative recipes specified in Python"
 readme = "README.md"
 license = {text = "BSD-3-Clause"}

{cook_build-0.6.3 → cook_build-0.6.4}/src/cook/__main__.py

@@ -122,6 +122,7 @@ class Command:
 
 class ExecArgs(Args):
     jobs: int
+    dry_run: bool
 
 
 class ExecCommand(Command):
@@ -135,11 +136,18 @@ class ExecCommand(Command):
         parser.add_argument(
             "--jobs", "-j", help="number of concurrent jobs", type=int, default=1
         )
+        parser.add_argument(
+            "--dry-run",
+            "-n",
+            help="show what \033[1mwould\033[0m be executed without running tasks",
+            action="store_true",
+            dest="dry_run",
+        )
         super().configure_parser(parser)
 
     def execute(self, controller: Controller, args: ExecArgs) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
         tasks = self.discover_tasks(controller, args)
-        controller.execute(tasks, num_concurrent=args.jobs)
+        controller.execute(tasks, num_concurrent=args.jobs, dry_run=args.dry_run)
 
 
 class LsArgs(Args):

{cook_build-0.6.3 → cook_build-0.6.4}/src/cook/controller.py

@@ -233,7 +233,11 @@ class Controller:
         return False
 
     def execute(
-        self, tasks: "Task | list[Task]", num_concurrent: int = 1, interval: float = 1
+        self,
+        tasks: "Task | list[Task]",
+        num_concurrent: int = 1,
+        interval: float = 1,
+        dry_run: bool = False,
     ) -> None:
         """
         Execute one or more tasks.
@@ -241,6 +245,8 @@ class Controller:
         Args:
             tasks: Tasks to execute.
             num_concurrent: Number of concurrent threads to run.
+            interval: Interval for checking stop events.
+            dry_run: If True, show what would execute without running tasks.
         """
         if not isinstance(tasks, Sequence):
             tasks = [tasks]
@@ -256,7 +262,7 @@ class Controller:
             thread = threading.Thread(
                 target=self._target,
                 name=f"cook-thread-{i}",
-                args=(stop, input_queue, output_queue),
+                args=(stop, input_queue, output_queue, dry_run),
                 daemon=True,
             )
             thread.start()
@@ -288,30 +294,35 @@ class Controller:
                 # Unpack the results.
                 if event.kind == "fail":
                     # Update the status in the database.
-                    params = {
-                        "name": event.task.name,
-                        "last_failed": event.timestamp,
-                    }
-                    self.connection.execute(QUERIES["upsert_task_failed"], params)
-                    self.connection.commit()
+                    if not dry_run:
+                        params = {
+                            "name": event.task.name,
+                            "last_failed": event.timestamp,
+                        }
+                        self.connection.execute(QUERIES["upsert_task_failed"], params)
+                        self.connection.commit()
                     ex = event.exc_info[1]
                     raise util.FailedTaskError(ex, task=event.task) from ex
                 elif event.kind == "complete":
                     # Update the status in the database.
-                    params = {
-                        "name": event.task.name,
-                        "digest": event.digest,
-                        "last_completed": event.timestamp,
-                    }
-                    self.connection.execute(QUERIES["upsert_task_completed"], params)
-                    self.connection.commit()
+                    if not dry_run:
+                        params = {
+                            "name": event.task.name,
+                            "digest": event.digest,
+                            "last_completed": event.timestamp,
+                        }
+                        self.connection.execute(
+                            QUERIES["upsert_task_completed"], params
+                        )
+                        self.connection.commit()
                 elif event.kind == "start":
-                    params = {
-                        "name": event.task.name,
-                        "last_started": event.timestamp,
-                    }
-                    self.connection.execute(QUERIES["upsert_task_started"], params)
-                    self.connection.commit()
+                    if not dry_run:
+                        params = {
+                            "name": event.task.name,
+                            "last_started": event.timestamp,
+                        }
+                        self.connection.execute(QUERIES["upsert_task_started"], params)
+                        self.connection.commit()
                     continue
                 else:
                     raise ValueError(event)  # pragma: no cover
@@ -345,7 +356,11 @@ class Controller:
                     raise RuntimeError(f"thread {thread} failed to join")
 
     def _target(
-        self, stop: util.StopEvent, input_queue: Queue, output_queue: Queue
+        self,
+        stop: util.StopEvent,
+        input_queue: Queue,
+        output_queue: Queue,
+        dry_run: bool = False,
     ) -> None:
         LOGGER.debug(f"started thread `{threading.current_thread().name}`")
         while not stop.is_set():
@@ -365,12 +380,28 @@ class Controller:
 
             start = datetime.now()
             try:
-                # Execute the task.
-                LOGGER.log(
-                    logging.DEBUG if task.name.startswith("_") else logging.INFO,
-                    "executing %s ...",
-                    task,
-                )
+                # Execute or simulate the task.
+                if dry_run:
+                    LOGGER.log(
+                        logging.DEBUG if task.name.startswith("_") else logging.INFO,
+                        "would execute %s",
+                        task,
+                    )
+                    if task.action:
+                        LOGGER.log(
+                            logging.DEBUG
+                            if task.name.startswith("_")
+                            else logging.INFO,
+                            "  action: %s",
+                            task.action,
+                        )
+                else:
+                    LOGGER.log(
+                        logging.DEBUG if task.name.startswith("_") else logging.INFO,
+                        "executing %s ...",
+                        task,
+                    )
+
                 output_queue.put(
                     Event(
                         kind="start",
@@ -380,15 +411,17 @@ class Controller:
                         exc_info=(None, None, None),
                     )
                 )
-                task.execute(stop)
 
-                # Check that all targets were created.
-                for target in task.targets:
-                    if not target.is_file():
-                        raise FileNotFoundError(
-                            f"task {task} did not create target {target}"
-                        )
-                    LOGGER.debug("%s created `%s`", task, target)
+                if not dry_run:
+                    task.execute(stop)
+
+                    # Check that all targets were created.
+                    for target in task.targets:
+                        if not target.is_file():
+                            raise FileNotFoundError(
+                                f"task {task} did not create target {target}"
+                            )
+                        LOGGER.debug("%s created `%s`", task, target)
 
                 # Add the result to the output queue and report success.
                 output_queue.put(
@@ -400,13 +433,14 @@ class Controller:
                         exc_info=(None, None, None),
                     )
                 )
-                delta = util.format_timedelta(datetime.now() - start)
-                LOGGER.log(
-                    logging.DEBUG if task.name.startswith("_") else logging.INFO,
-                    "completed %s in %s",
-                    task,
-                    delta,
-                )
+                if not dry_run:
+                    delta = util.format_timedelta(datetime.now() - start)
+                    LOGGER.log(
+                        logging.DEBUG if task.name.startswith("_") else logging.INFO,
+                        "completed %s in %s",
+                        task,
+                        delta,
+                    )
             except:  # noqa: E722
                 exc_info = sys.exc_info()
                 delta = util.format_timedelta(datetime.now() - start)

{cook_build-0.6.3 → cook_build-0.6.4/src/cook_build.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cook-build
-Version: 0.6.3
+Version: 0.6.4
 Summary: A task-centric build system with simple declarative recipes specified in Python
 Author: Till Hoffmann
 License: BSD-3-Clause

{cook_build-0.6.3 → cook_build-0.6.4}/tests/test_main.py

@@ -127,3 +127,66 @@ def test_terrible_recipe(caplog: pytest.LogCaptureFixture) -> None:
     with pytest.raises(SystemExit), caplog.at_level("CRITICAL"):
         __main__(["--recipe", str(RECIPES / "terrible.not-py"), "ls"])
     assert "failed to load recipe" in caplog.text
+
+
+def test_dry_run_shows_tasks(tmp_wd: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """Dry-run should show what would execute without running tasks."""
+    with caplog.at_level(logging.INFO):
+        __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "--dry-run", "run"])
+
+    # Should show "would execute" messages
+    assert "would execute <task `create_source`" in caplog.text
+    assert "would execute <task `compile`" in caplog.text
+    assert "would execute <task `link`" in caplog.text
+    assert "would execute <task `run`" in caplog.text
+
+    # Should show actions
+    assert "action:" in caplog.text
+
+    # Should NOT show "executing" or "completed" messages
+    assert "executing <task" not in caplog.text
+    assert "completed <task" not in caplog.text
+
+
+def test_dry_run_does_not_create_files(tmp_wd: Path) -> None:
+    """Dry-run should not create target files."""
+    __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "--dry-run", "link"])
+
+    # Files should NOT be created
+    assert not (tmp_wd / "blah.c").exists()
+    assert not (tmp_wd / "blah.o").exists()
+    assert not (tmp_wd / "blah").exists()
+
+
+def test_dry_run_does_not_update_database(tmp_wd: Path) -> None:
+    """Dry-run should not update the database."""
+    # First, run normally to create database entry
+    __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "link"])
+
+    # Check the database was updated
+    __main__(["--recipe", str(RECIPES / "blah.py"), "info", "link"])
+
+    # Reset the task
+    __main__(["--recipe", str(RECIPES / "blah.py"), "reset", "link"])
+
+    # Now dry-run should not update last_completed
+    __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "--dry-run", "link"])
+
+    # Task should still be stale (database not updated)
+    __main__(["--recipe", str(RECIPES / "blah.py"), "info", "--stale", "link"])
+
+
+def test_dry_run_with_no_stale_tasks(
+    tmp_wd: Path, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Dry-run with no stale tasks should be silent."""
+    # First, run normally
+    __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "link"])
+
+    # Now dry-run with nothing stale
+    caplog.clear()
+    with caplog.at_level(logging.INFO):
+        __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "--dry-run", "link"])
+
+    # Should be silent (no "would execute" messages)
+    assert "would execute" not in caplog.text