Merge pull request #82 from stuartskelton/Add_list_completed

Add list completed

6 files changed, 133 insertions, 14 deletions

diff --git a/todo.go b/todo.go
index f9dcd6c..c099fc7 100644
--- a/todo.go
+++ b/todo.go
@@ -58,6 +58,14 @@ func usage() {
 	yellow.Println("\ttodo agenda")
 	fmt.Println("\tlists all todos where the due date is today or in the past\n")
 
+	fmt.Println("  todo l completed (tod|today|this week)")
+	cyan.Println("  Filtering by date:\n")
+
+	yellow.Println("\ttodo l completed (tod|today)")
+	fmt.Println("\tlists all todos that were completed today\n")
+	yellow.Println("\ttodo l completed this week")
+	fmt.Println("\tlists all todos that were completed this week\n")
+
 	cyan.Println("  Grouping:")
 	fmt.Println("  You can group todos by context or project.")
 	yellow.Println("\ttodo l by c")
diff --git a/todolist/date_filter.go b/todolist/date_filter.go
index cccd869..b91bee3 100644
--- a/todolist/date_filter.go
+++ b/todolist/date_filter.go
@@ -14,19 +14,28 @@ func NewDateFilter(todos []*Todo) *DateFilter {
 	return &DateFilter{Todos: todos, Location: time.Now().Location()}
 }
 
+func filterOnDue(todo *Todo) string {
+	return todo.Due
+}
+
+func filterOnCompletedDate(todo *Todo) string {
+	return todo.CompletedDateToDate()
+}
+
 func (f *DateFilter) FilterDate(input string) []*Todo {
 	agendaRegex, _ := regexp.Compile(`agenda.*$`)
 	if agendaRegex.MatchString(input) {
 		return f.filterAgenda(bod(time.Now()))
 	}
 
+	// filter due items
 	r, _ := regexp.Compile(`due .*$`)
 	match := r.FindString(input)
 	switch {
 	case match == "due tod" || match == "due today":
-		return f.filterToday(bod(time.Now()))
+		return f.filterDueToday(bod(time.Now()))
 	case match == "due tom" || match == "due tomorrow":
-		return f.filterTomorrow(bod(time.Now()))
+		return f.filterDueTomorrow(bod(time.Now()))
 	case match == "due sun" || match == "due sunday":
 		return f.filterDay(bod(time.Now()), time.Sunday)
 	case match == "due mon" || match == "due monday":
@@ -50,6 +59,17 @@ func (f *DateFilter) FilterDate(input string) []*Todo {
 	case match == "overdue":
 		return f.filterOverdue(bod(time.Now()))
 	}
+
+	// filter completed items
+	r, _ = regexp.Compile(`completed .*$`)
+	match = r.FindString(input)
+	switch {
+	case match == "completed tod" || match == "completed today":
+		return f.filterCompletedToday(bod(time.Now()))
+	case match == "completed this week":
+		return f.filterCompletedThisWeek(bod(time.Now()))
+	}
+
 	return f.Todos
 }
 
@@ -68,23 +88,27 @@ func (f *DateFilter) filterAgenda(pivot time.Time) []*Todo {
 	return ret
 }
 
-func (f *DateFilter) filterToExactDate(pivot time.Time) []*Todo {
+func (f *DateFilter) filterToExactDate(pivot time.Time, filterOn func(*Todo) string) []*Todo {
 	var ret []*Todo
 	for _, todo := range f.Todos {
-		if todo.Due == pivot.Format("2006-01-02") {
+		if filterOn(todo) == pivot.Format("2006-01-02") {
 			ret = append(ret, todo)
 		}
 	}
 	return ret
 }
 
-func (f *DateFilter) filterToday(pivot time.Time) []*Todo {
-	return f.filterToExactDate(pivot)
+func (f *DateFilter) filterDueToday(pivot time.Time) []*Todo {
+	return f.filterToExactDate(pivot, filterOnDue)
 }
 
-func (f *DateFilter) filterTomorrow(pivot time.Time) []*Todo {
+func (f *DateFilter) filterDueTomorrow(pivot time.Time) []*Todo {
 	pivot = pivot.AddDate(0, 0, 1)
-	return f.filterToExactDate(pivot)
+	return f.filterToExactDate(pivot, filterOnDue)
+}
+
+func (f *DateFilter) filterCompletedToday(pivot time.Time) []*Todo {
+	return f.filterToExactDate(pivot, filterOnCompletedDate)
 }
 
 func (f *DateFilter) filterDay(pivot time.Time, day time.Weekday) []*Todo {
@@ -100,11 +124,11 @@ func (f *DateFilter) filterDay(pivot time.Time, day time.Weekday) []*Todo {
 	return ret
 }
 
-func (f *DateFilter) filterBetweenDatesInclusive(begin, end time.Time) []*Todo {
+func (f *DateFilter) filterBetweenDatesInclusive(begin, end time.Time, filterOn func(*Todo) string) []*Todo {
 	var ret []*Todo
 
 	for _, todo := range f.Todos {
-		dueTime, _ := time.ParseInLocation("2006-01-02", todo.Due, f.Location)
+		dueTime, _ := time.ParseInLocation("2006-01-02", filterOn(todo), f.Location)
 		if (begin.Before(dueTime) || begin.Equal(dueTime)) && end.After(dueTime) {
 			ret = append(ret, todo)
 		}
@@ -117,7 +141,15 @@ func (f *DateFilter) filterThisWeek(pivot time.Time) []*Todo {
 	begin := bod(f.FindSunday(pivot))
 	end := begin.AddDate(0, 0, 7)
 
-	return f.filterBetweenDatesInclusive(begin, end)
+	return f.filterBetweenDatesInclusive(begin, end, filterOnDue)
+}
+
+func (f *DateFilter) filterCompletedThisWeek(pivot time.Time) []*Todo {
+
+	begin := bod(f.FindSunday(pivot))
+	end := begin.AddDate(0, 0, 7)
+
+	return f.filterBetweenDatesInclusive(begin, end, filterOnCompletedDate)
 }
 
 func (f *DateFilter) filterBetweenDatesExclusive(begin, end time.Time) []*Todo {
diff --git a/todolist/date_filter_test.go b/todolist/date_filter_test.go
index 6dd88f6..8078fb3 100644
--- a/todolist/date_filter_test.go
+++ b/todolist/date_filter_test.go
@@ -17,7 +17,7 @@ func TestFilterToday(t *testing.T) {
 	todos = append(todos, tomorrowTodo)
 
 	filter := NewDateFilter(todos)
-	filtered := filter.filterToday(time.Now())
+	filtered := filter.filterDueToday(time.Now())
 
 	assert.Equal(1, len(filtered))
 	assert.Equal(1, filtered[0].Id)
@@ -33,12 +33,42 @@ func TestFilterTomorrow(t *testing.T) {
 	todos = append(todos, tomorrowTodo)
 
 	filter := NewDateFilter(todos)
-	filtered := filter.filterTomorrow(time.Now())
+	filtered := filter.filterDueTomorrow(time.Now())
 
 	assert.Equal(1, len(filtered))
 	assert.Equal(2, filtered[0].Id)
 }
 
+func TestFilterCompletedToday(t *testing.T) {
+	assert := assert.New(t)
+
+	var todos []*Todo
+	todoNo1 := &Todo{Id: 1, Subject: "one", Due: time.Now().Format("2006-01-02")}
+	todoNo2 := &Todo{Id: 2, Subject: "two", Due: time.Now().Format("2006-01-02")}
+
+	todos = append(todos, todoNo1)
+	todos = append(todos, todoNo2)
+
+	filter := NewDateFilter(todos)
+	filtered := filter.filterCompletedToday(time.Now())
+
+	assert.Equal(0, len(filtered))
+
+	todoNo1.Complete()
+	filtered = filter.filterCompletedToday(time.Now())
+
+	assert.Equal(1, len(filtered))
+	assert.Equal(1, filtered[0].Id)
+
+	todoNo1.Uncomplete()
+	todoNo2.Complete()
+	filtered = filter.filterCompletedToday(time.Now())
+
+	assert.Equal(1, len(filtered))
+	assert.Equal(2, filtered[0].Id)
+
+}
+
 func TestFilterThisWeek(t *testing.T) {
 	assert := assert.New(t)
 
@@ -57,6 +87,30 @@ func TestFilterThisWeek(t *testing.T) {
 	assert.Equal(2, filtered[0].Id)
 }
 
+func TestFilterCompletedThisWeek(t *testing.T) {
+	assert := assert.New(t)
+
+	var todos []*Todo
+	lastWeekTodo := &Todo{Id: 1, Subject: "two", Due: time.Now().AddDate(0, 0, -7).Format("2006-01-02")}
+	todayTodo := &Todo{Id: 2, Subject: "one", Due: time.Now().Format("2006-01-02")}
+	nextWeekTodo := &Todo{Id: 3, Subject: "two", Due: time.Now().AddDate(0, 0, 8).Format("2006-01-02")}
+	todos = append(todos, lastWeekTodo)
+	todos = append(todos, todayTodo)
+	todos = append(todos, nextWeekTodo)
+
+	filter := NewDateFilter(todos)
+	filtered := filter.filterCompletedThisWeek(time.Now())
+
+	assert.Equal(0, len(filtered))
+
+	todayTodo.Complete()
+	filtered = filter.filterCompletedThisWeek(time.Now())
+
+	assert.Equal(1, len(filtered))
+	assert.Equal(2, filtered[0].Id)
+
+}
+
 func TestFilterOverdue(t *testing.T) {
 	assert := assert.New(t)
 
diff --git a/todolist/filter.go b/todolist/filter.go
index 8c2a7ad..dd61d11 100644
--- a/todolist/filter.go
+++ b/todolist/filter.go
@@ -31,6 +31,13 @@ func (t *TodoFilter) isFilteringByContexts(input string) bool {
 }
 
 func (f *TodoFilter) filterArchived(input string) []*Todo {
+
+	// do not filter archived if want completed items
+	completedRegex, _ := regexp.Compile(`completed`)
+	if completedRegex.MatchString(input) {
+		return f.Todos
+	}
+
 	r, _ := regexp.Compile(`l archived$`)
 	if r.MatchString(input) {
 		return f.getArchived()
diff --git a/todolist/filter_test.go b/todolist/filter_test.go
index e4d3fed..c3bedbf 100644
--- a/todolist/filter_test.go
+++ b/todolist/filter_test.go
@@ -30,6 +30,19 @@ func TestFilterUnarchivedByDefault(t *testing.T) {
 	assert.Equal(false, unarchived[0].Archived)
 }
 
+func TestFilterShowArchivedWhenWeAskForCompleted(t *testing.T) {
+	assert := assert.New(t)
+	store := &FileStore{FileLocation: "todos.json"}
+	list := &TodoList{}
+	todos, _ := store.Load()
+	list.Load(todos)
+	filter := NewFilter(list.Todos())
+	unarchived := filter.filterArchived("completed")
+	assert.Equal(2, len(unarchived))
+	assert.Equal(false, unarchived[0].Archived)
+	assert.Equal(true, unarchived[1].Archived)
+}
+
 func TestGetArchived(t *testing.T) {
 	assert := assert.New(t)
 	store := &FileStore{FileLocation: "todos.json"}
diff --git a/todolist/todo_item.go b/todolist/todo_item.go
index 859e946..eecb409 100644
--- a/todolist/todo_item.go
+++ b/todolist/todo_item.go
@@ -43,4 +43,9 @@ func (t *Todo) Complete() {
 func (t *Todo) Uncomplete() {
 	t.Completed = false
 	t.CompletedDate = ""
-}
\ No newline at end of file
+}
+
+func (t Todo) CompletedDateToDate() string {
+	parsedTime, _ := time.Parse(ISO8601_TIMESTAMP_FORMAT, t.CompletedDate)
+	return parsedTime.Format("2006-01-02")
+}