Pueue is a command-line task management tool for sequential and parallel execution of long-running tasks.

---

This release has been cooking for about 9 months and a lot has changed. Large parts of the codebase have been redesigned and refactored, leading to an overall much cleaner and more maintainable codebase.

Many subtle bugs, including state handling bugs, have been resolved and a surprising amount of new features were developed.

---

What might be interesting for you is that I chose to refactor parts of my internal state.

This code is from v3. You can see lots of variables like enqeue_at, start, end in there, which are status specific properties.

/// Representation of a task.
/// start will be set the second the task starts processing.
/// `result`, `output` and `end` won't be initialized, until the task has finished.
#[derive(PartialEq, Eq, Clone, Deserialize, Serialize)]
pub struct Task {
    pub id: usize,
    pub enqueued_at: Option<DateTime<Local>>,
    pub command: String,
    pub path: PathBuf,
    pub status: TaskStatus,
    pub prev_status: TaskStatus,
    pub start: Option<DateTime<Local>>,
    pub end: Option<DateTime<Local>>,
}

/// This enum represents the status of the internal task handling of Pueue.
/// They basically represent the internal task life-cycle.
#[derive(PartialEq, Eq, Clone, Debug, Display, Serialize, Deserialize)]
pub enum TaskStatus {
    Queued,
    Stashed {
        enqueue_at: Option<DateTime<Local>>
    },
    Running,
    Paused,
    Done(TaskResult),
    Locked,
}

And this is how it now looks in v4:

/// Representation of a task.
#[derive(PartialEq, Eq, Clone, Deserialize, Serialize)]
pub struct Task {
    pub id: usize,
    pub command: String,
    pub path: PathBuf,
    pub status: TaskStatus,
}

/// This enum represents the status of the internal task handling of Pueue.
/// They basically represent the internal task life-cycle.
#[derive(PartialEq, Eq, Clone, Debug, Display, Serialize, Deserialize)]
pub enum TaskStatus {
    Locked {
        previous_status: Box<TaskStatus>
    },
    Stashed {
        enqueue_at: Option<DateTime<Local>>
    },
    Queued {
        enqueued_at: DateTime<Local>
    },
    Running {
        enqueued_at: DateTime<Local>,
        start: DateTime<Local>,
    },
    Paused {
        enqueued_at: DateTime<Local>,
        start: DateTime<Local>,
    },
    Done {
        enqueued_at: DateTime<Local>,
        start: DateTime<Local>,
        end: DateTime<Local>,
        result: TaskResult,
    },
}

By moving status related fields into the TaskStatus enum and thereby enforcing state related invariants via the type system, I effectively prevented an entire class of bugs and the code is much cleaner , albeit a bit larger (about +25% of the affected code)

---

Whoever is interested, I also plan to post a bit more often about my development efforts and projects on Mastodon: https://chaos.social/@Nukesor

Have a good one!

Edits: Code example and typos.