Replace Days with a freeform string describing when a task is due

Examples:
  1 day before start
  4.5 hours after start
  4 days before end
  etc.

Author: seanrees

main.go

@@ -191,12 +191,18 @@ func createProject(uc *userConfig, trip tripit.Trip, cl []tasks.ChecklistItem, t
 		return
 	}
 
+	end, err := trip.End()
+	if err != nil {
+		log.Printf("Unable to get end date from trip: %v\n", err)
+		return
+	}
+
 	name := fmt.Sprintf("Trip: %s", trip.DisplayName)
 	log.Printf("Processing %s", name)
 
 	p := tasks.Project{
 		Name:  name,
-		Tasks: tasks.Expand(cl, start, taskCutoff)}
+		Tasks: tasks.Expand(cl, start, end, taskCutoff)}
 
 	if p.Empty() {
 		log.Println("No tasks within cutoff window, skipping.")

tasks/checklist.go

@@ -7,24 +7,14 @@ import (
 	"os"
 	"strconv"
 	"strings"
-	"time"
 )
 
 type ChecklistItem struct {
 	Template string
 
 	Indent int
 
-	// This may not be expressive enough. E.g; some tasks might want to be quantised to units
-	// of weekends rather than days. I suspect anything sub-day is not useful.
-	Days int
-}
-
-func (t ChecklistItem) Due(due time.Time) time.Time {
-	// Add (probably subtract) the relevant t.Days from the given due time, then add back
-	// 20 hours to actually complete the task. This works best with tasks due at the *start*
-	// of some day, e.g; at 00:00.
-	return due.Add(time.Duration(t.Days) * 24 * time.Hour).Add(20 * time.Hour)
+	Due string
 }
 
 func Load(templateFilename string) ([]ChecklistItem, error) {
@@ -66,16 +56,10 @@ func load(ior io.Reader) ([]ChecklistItem, error) {
 			continue
 		}
 
-		d, err := strconv.Atoi(rec[2])
-		if err != nil {
-			errors = append(errors, fmt.Sprintf("line %d: %v", l, err))
-			continue
-		}
-
 		ret = append(ret, ChecklistItem{
 			Template: rec[0],
 			Indent:   i,
-			Days:     d,
+			Due:      rec[2],
 		})
 	}
 

tasks/checklist_test.go

@@ -16,28 +16,24 @@ func TestLoad(t *testing.T) {
 		want: []ChecklistItem{},
 		err:  false,
 	}, {
-		csv:  "foo,1,1",
-		want: []ChecklistItem{{"foo", 1, 1}},
+		csv:  "foo,1,1 day before start",
+		want: []ChecklistItem{{"foo", 1, "1 day before start"}},
 		err:  false,
 	}, {
-		csv:  "foo,1,1\nbar,1,2",
-		want: []ChecklistItem{{"foo", 1, 1}, {"bar", 1, 2}},
+		csv:  "foo,1,bizzle\nbar,1,wizzle",
+		want: []ChecklistItem{{"foo", 1, "bizzle"}, {"bar", 1, "wizzle"}},
 		err:  false,
 	}, {
-		csv:  "foo,1,not-a-num",
+		csv:  "foo\nbar,1,error",
 		want: []ChecklistItem{},
 		err:  true,
 	}, {
-		csv:  "foo\nbar,1,1",
-		want: []ChecklistItem{},
-		err:  true,
-	}, {
-		csv:  "foo,1,1\nnot-enough-fields\nbar,3,2",
-		want: []ChecklistItem{{"foo", 1, 1}, {"bar", 3, 2}},
+		csv:  "foo,1,e\nnot-enough-fields\nbar,3,f",
+		want: []ChecklistItem{{"foo", 1, "e"}, {"bar", 3, "f"}},
 		err:  true,
 	}, {
-		csv:  "foo,0,1\nbar,5,1\nbaz,1,1", // Indent out of range.
-		want: []ChecklistItem{{"baz", 1, 1}},
+		csv:  "foo,0,oof\nbar,5,rab\nbaz,1,zab", // Indent out of range.
+		want: []ChecklistItem{{"baz", 1, "zab"}},
 		err:  true,
 	}}
 

tasks/expand.go

@@ -1,25 +1,132 @@
 package tasks
 
 import (
+	"fmt"
+	"log"
+	"strconv"
+	"strings"
 	"time"
 )
 
+type due struct {
+	duration time.Duration
+
+	// end is true if the duration should be counted from the end of
+	// the trip.
+	end bool
+}
+
+func abs(t time.Duration) time.Duration {
+	if t < 0 {
+		return -t
+	}
+	return t
+}
+
 // Expand expands a travel checklist into a list of Tasks. If a task has a due date
 // after cutoff, it is ignored.
-func Expand(cl []ChecklistItem, start, cutoff time.Time) []Task {
+func Expand(cl []ChecklistItem, start, end, cutoff time.Time) []Task {
 	ret := []Task{}
 
 	for pos, i := range cl {
-		due := i.Due(start)
-		if due.Before(cutoff) {
+		var dd time.Time
+		d, err := parseDue(i.Due)
+		if err != nil {
+			log.Printf("Could not process due for task %q: %v (ignored)", i.Template, err)
+			continue
+		}
+		if d.end {
+			dd = end.Add(d.duration)
+		} else {
+			dd = start.Add(d.duration)
+		}
+		if abs(d.duration) >= 24*time.Hour {
+			dd = time.Date(dd.Year(), dd.Month(), dd.Day(), 20, 00, 00, 00, time.UTC)
+		}
+
+		if dd.Before(cutoff) {
 			ret = append(ret, Task{
 				Content:  i.Template,
 				Indent:   i.Indent,
-				DueDate:  due,
+				DueDate:  dd,
 				Position: pos,
 			})
 		}
 	}
 
 	return ret
 }
+
+// parseDue expands a humanized due string into a due structure. A due
+// string looks like: "16 hours before start" or "1 day after end"
+func parseDue(s string) (due, error) {
+	var ret due
+	parts := strings.SplitN(strings.ToLower(s), " ", 4)
+	if len(parts) < 4 {
+		return ret, fmt.Errorf("due date not fully specified %q", s)
+	}
+
+	t, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return ret, err
+	}
+
+	switch d := parts[1]; d {
+	case "minute":
+		fallthrough
+	case "minutes":
+		ret.duration = time.Duration(t) * time.Minute
+
+	case "hour":
+		fallthrough
+	case "hours":
+		ret.duration = time.Duration(t) * time.Hour
+
+	case "day":
+		fallthrough
+	case "days":
+		ret.duration = time.Duration(t*24) * time.Hour
+
+	case "week":
+		fallthrough
+	case "weeks":
+		ret.duration = time.Duration(t*24*7) * time.Hour
+
+	default:
+		// Just try it.
+		ret.duration, err = time.ParseDuration(d)
+		if err != nil {
+			return ret, fmt.Errorf("unknown unit %q", d)
+		}
+	}
+
+	switch parts[2] {
+	case "after":
+		// Nothing.
+
+	case "from":
+		fallthrough
+	case "before":
+		ret.duration = -ret.duration
+
+	default:
+		return ret, fmt.Errorf("unknown relation %q", parts[2])
+	}
+
+	switch parts[3] {
+	case "departure":
+		fallthrough
+	case "start":
+		// Nothing.
+
+	case "return":
+		fallthrough
+	case "end":
+		ret.end = true
+
+	default:
+		return ret, fmt.Errorf("unknown reference %q", parts[3])
+	}
+
+	return ret, nil
+}

tasks/expand_test.go

@@ -8,26 +8,50 @@ import (
 
 func TestExpand(t *testing.T) {
 	tripStart := time.Date(2016, 07, 15, 00, 00, 00, 00, time.UTC)
-	cutoff := time.Date(2016, 07, 10, 00, 00, 00, 00, time.UTC)
+	tripEnd := time.Date(2016, 07, 20, 12, 30, 00, 00, time.UTC)
+	stdCutoff := time.Date(2016, 07, 10, 00, 00, 00, 00, time.UTC)
 
 	cases := []struct {
-		in   []ChecklistItem
-		want []Task
+		in     []ChecklistItem
+		cutoff time.Time
+		want   []Task
 	}{{
 		in:   []ChecklistItem{},
 		want: []Task{},
 	}, {
-		in: []ChecklistItem{{Template: "foo", Indent: 1, Days: -14}},
+		in:     []ChecklistItem{{Template: "foo", Indent: 1, Due: "14 days before start"}},
+		cutoff: stdCutoff,
 		want: []Task{{
 			Content: "foo",
 			Indent:  1,
 			DueDate: time.Date(2016, 07, 01, 20, 00, 00, 00, time.UTC),
 		}},
 	}, {
 		in: []ChecklistItem{
-			{Template: "before cutoff", Indent: 1, Days: -8},
-			{Template: "after cutoff", Indent: 1, Days: -4},
+			{Template: "no day adjustment", Indent: 1, Due: "1 hour before start"},
+			{Template: "end", Indent: 1, Due: "2 days before end"},
+			{Template: "after", Indent: 1, Due: "4 hours after start"},
 		},
+		cutoff: tripEnd,
+		want: []Task{
+			{Content: "no day adjustment",
+				Indent:  1,
+				DueDate: time.Date(2016, 07, 14, 23, 00, 00, 00, time.UTC)},
+			{Content: "end",
+				Indent:  1,
+                Position: 1,
+				DueDate: time.Date(2016, 07, 18, 20, 00, 00, 00, time.UTC)},
+			{Content: "after",
+				Indent: 1,
+                Position: 2,
+                DueDate: time.Date(2016, 07, 15, 04, 00, 00, 00, time.UTC)},
+		},
+	}, {
+		in: []ChecklistItem{
+			{Template: "before cutoff", Indent: 1, Due: "8 days before start"},
+			{Template: "after cutoff", Indent: 1, Due: "4 days before start"},
+		},
+        cutoff: stdCutoff,
 		want: []Task{{
 			Content: "before cutoff",
 			Indent:  1,
@@ -36,9 +60,58 @@ func TestExpand(t *testing.T) {
 	}}
 
 	for _, c := range cases {
-		got := Expand(c.in, tripStart, cutoff)
+		got := Expand(c.in, tripStart, tripEnd, c.cutoff)
 		if !reflect.DeepEqual(got, c.want) {
 			t.Errorf("Expand(%v) == %v, want %v", c.in, got, c.want)
 		}
 	}
 }
+
+func TestParseDue(t *testing.T) {
+	cases := []struct {
+		in        string
+		want      due
+		wantError bool
+	}{{
+		in:   "1 hour from start",
+		want: due{duration: -time.Hour},
+	}, {
+		in:   "3 hours after end",
+		want: due{duration: 3 * time.Hour, end: true},
+	}, {
+		in:   "1 day before end",
+		want: due{duration: -24 * time.Hour, end: true},
+	}, {
+		in:   "2 weeks before start",
+		want: due{duration: -2 * 7 * 24 * time.Hour},
+	}, {
+		in:        "",
+		wantError: true,
+	}, {
+		in:        "A days before start",
+		wantError: true,
+	}, {
+		in:        "1 month before start", // month not supported.
+		wantError: true,
+	}, {
+		in:        "1 day prior to start", // prior to not supported.
+		wantError: true,
+	}, {
+		in:        "1 day before commencement",
+		wantError: true,
+	}}
+
+	for _, c := range cases {
+		got, err := parseDue(c.in)
+		if err != nil {
+			if !c.wantError {
+				t.Errorf("parseDue(%q) error %v want no error", c.in, err)
+			}
+			continue
+		}
+		if !reflect.DeepEqual(got, c.want) {
+			t.Errorf("parseDue(%q) == %v want %v", c.in, got, c.want)
+		}
+	}
+
+}