From 6584af446f0fe1ddff8ceb834c362432adcee9d8 Mon Sep 17 00:00:00 2001 From: Amolith Date: Mon, 22 Dec 2025 08:30:55 -0700 Subject: [PATCH] refactor(eisenhower): extract to file, add String Move Eisenhower type, constants, and methods from types.go to eisenhower.go. Add String() method returning human-readable quadrant descriptions for CLI display. Assisted-by: Claude Sonnet 4 via Crush --- eisenhower.go | 79 ++++++++++++++++++++++++++++++++++++++++++++++ eisenhower_test.go | 39 +++++++++++++++++++++++ types.go | 54 ------------------------------- 3 files changed, 118 insertions(+), 54 deletions(-) create mode 100644 eisenhower.go diff --git a/eisenhower.go b/eisenhower.go new file mode 100644 index 0000000000000000000000000000000000000000..6603ca1fdc22c9394e0f9bad3466371db84582e9 --- /dev/null +++ b/eisenhower.go @@ -0,0 +1,79 @@ +// SPDX-FileCopyrightText: Amolith +// +// SPDX-License-Identifier: AGPL-3.0-or-later + +package lunatask + +import "fmt" + +// Eisenhower represents a quadrant in the Eisenhower priority matrix, which +// categorizes tasks by whether they are urgent (time-sensitive) and/or +// important (valuable toward your goals). +// +// The four quadrants guide what action to take: +// +// | Urgent | Not Urgent +// ------------------|---------------|------------- +// Important | Do Now (1) | Do Later (3) +// Not Important | Delegate (2) | Eliminate (4) +// +// Use [NewEisenhower] to compute the quadrant from boolean flags, or the +// builder methods [TaskBuilder.Important] and [TaskBuilder.Urgent] for a +// fluent API. +type Eisenhower int + +// Eisenhower matrix quadrants. See [Eisenhower] for the full matrix. +const ( + EisenhowerUncategorized Eisenhower = 0 // not yet categorized + EisenhowerDoNow Eisenhower = 1 // urgent + important + EisenhowerDelegate Eisenhower = 2 // urgent, not important + EisenhowerDoLater Eisenhower = 3 // important, not urgent + EisenhowerEliminate Eisenhower = 4 // neither urgent nor important +) + +// NewEisenhower returns the quadrant for the given flags: +// +// NewEisenhower(true, true) // DoNow +// NewEisenhower(true, false) // DoLater +// NewEisenhower(false, true) // Delegate +// NewEisenhower(false, false) // Eliminate +func NewEisenhower(important, urgent bool) Eisenhower { + switch { + case important && urgent: + return EisenhowerDoNow + case urgent: + return EisenhowerDelegate + case important: + return EisenhowerDoLater + default: + return EisenhowerEliminate + } +} + +// String returns a human-readable description of the Eisenhower quadrant. +func (e Eisenhower) String() string { + switch e { + case EisenhowerUncategorized: + return "uncategorized" + case EisenhowerDoNow: + return "do now (important + urgent)" + case EisenhowerDelegate: + return "delegate (urgent)" + case EisenhowerDoLater: + return "do later (important)" + case EisenhowerEliminate: + return "eliminate" + default: + return fmt.Sprintf("Eisenhower(%d)", e) + } +} + +// IsUrgent reports whether e is in an urgent quadrant ([EisenhowerDoNow] or [EisenhowerDelegate]). +func (e Eisenhower) IsUrgent() bool { + return e == EisenhowerDoNow || e == EisenhowerDelegate +} + +// IsImportant reports whether e is in an important quadrant ([EisenhowerDoNow] or [EisenhowerDoLater]). +func (e Eisenhower) IsImportant() bool { + return e == EisenhowerDoNow || e == EisenhowerDoLater +} diff --git a/eisenhower_test.go b/eisenhower_test.go index bf8f7816905a14a4b1d5bd1d9af0110b63c32849..008b571f0c890aded15be9d2d7143dd0343c83ac 100644 --- a/eisenhower_test.go +++ b/eisenhower_test.go @@ -10,6 +10,45 @@ import ( lunatask "git.secluded.site/go-lunatask" ) +// --- Eisenhower String Method --- + +func TestEisenhower_String(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + value lunatask.Eisenhower + want string + }{ + {"uncategorized", lunatask.EisenhowerUncategorized, "uncategorized"}, + {"do_now", lunatask.EisenhowerDoNow, "do now (important + urgent)"}, + {"delegate", lunatask.EisenhowerDelegate, "delegate (urgent)"}, + {"do_later", lunatask.EisenhowerDoLater, "do later (important)"}, + {"eliminate", lunatask.EisenhowerEliminate, "eliminate"}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + + if got := tc.value.String(); got != tc.want { + t.Errorf("Eisenhower(%d).String() = %q, want %q", tc.value, got, tc.want) + } + }) + } +} + +func TestEisenhower_String_Unknown(t *testing.T) { + t.Parallel() + + unknown := lunatask.Eisenhower(99) + want := "Eisenhower(99)" + + if got := unknown.String(); got != want { + t.Errorf("Eisenhower(99).String() = %q, want %q", got, want) + } +} + // --- Eisenhower Type Constants --- func TestEisenhower_Constants(t *testing.T) { diff --git a/types.go b/types.go index 8a509a703ca2f801f9ac6cdb6b4896b499d13d73..6668e607209de0e65439630e6df85d7a3290843b 100644 --- a/types.go +++ b/types.go @@ -127,57 +127,3 @@ const ( MotivationShould Motivation = "should" MotivationWant Motivation = "want" ) - -// Eisenhower represents a quadrant in the Eisenhower priority matrix, which -// categorizes tasks by whether they are urgent (time-sensitive) and/or -// important (valuable toward your goals). -// -// The four quadrants guide what action to take: -// -// | Urgent | Not Urgent -// ------------------|---------------|------------- -// Important | Do Now (1) | Do Later (3) -// Not Important | Delegate (2) | Eliminate (4) -// -// Use [NewEisenhower] to compute the quadrant from boolean flags, or the -// builder methods [TaskBuilder.Important] and [TaskBuilder.Urgent] for a -// fluent API. -type Eisenhower int - -// Eisenhower matrix quadrants. See [Eisenhower] for the full matrix. -const ( - EisenhowerUncategorized Eisenhower = 0 // not yet categorized - EisenhowerDoNow Eisenhower = 1 // urgent + important - EisenhowerDelegate Eisenhower = 2 // urgent, not important - EisenhowerDoLater Eisenhower = 3 // important, not urgent - EisenhowerEliminate Eisenhower = 4 // neither urgent nor important -) - -// NewEisenhower returns the quadrant for the given flags: -// -// NewEisenhower(true, true) // DoNow -// NewEisenhower(true, false) // DoLater -// NewEisenhower(false, true) // Delegate -// NewEisenhower(false, false) // Eliminate -func NewEisenhower(important, urgent bool) Eisenhower { - switch { - case important && urgent: - return EisenhowerDoNow - case urgent: - return EisenhowerDelegate - case important: - return EisenhowerDoLater - default: - return EisenhowerEliminate - } -} - -// IsUrgent reports whether e is in an urgent quadrant ([EisenhowerDoNow] or [EisenhowerDelegate]). -func (e Eisenhower) IsUrgent() bool { - return e == EisenhowerDoNow || e == EisenhowerDelegate -} - -// IsImportant reports whether e is in an important quadrant ([EisenhowerDoNow] or [EisenhowerDoLater]). -func (e Eisenhower) IsImportant() bool { - return e == EisenhowerDoNow || e == EisenhowerDoLater -}