Reduce complexity by breaking larger functions down

This commit reduces complexity by breaking bigger functions into
smaller, and moving some state around, etc.

There should be no functional change.

Author: skx

chooseui/chooseui.go

@@ -21,6 +21,15 @@ type ChooseUI struct {
 
 	// The users' choice.
 	chosen string
+
+	// app is the global application
+	app *tview.Application
+
+	// list contains the global list of text-entries.
+	list *tview.List
+
+	// inputField contains the global text-input field.
+	inputField *tview.InputField
 }
 
 // New creates a new UI, allowing the user to select from the available options.
@@ -30,81 +39,69 @@ func New(choices []string) *ChooseUI {
 }
 
 // Choose launches our user interface.
-func (ui *ChooseUI) Choose() string {
+func (ui *ChooseUI) SetupUI() {
 
 	//
 	// Create the console-GUI application.
 	//
-	app := tview.NewApplication()
+	ui.app = tview.NewApplication()
 
 	//
 	// Create a list to hold our files.
 	//
-	list := tview.NewList()
-	list.ShowSecondaryText(false)
-	list.SetWrapAround(false)
+	ui.list = tview.NewList()
+	ui.list.ShowSecondaryText(false)
+	ui.list.SetWrapAround(false)
 
 	//
 	// Add all the choices to it.
 	//
 	for _, entry := range ui.Choices {
-		list.AddItem(entry, "", ' ', nil)
+		ui.list.AddItem(entry, "", ' ', nil)
 	}
 
-	//
-	// If the user presses return in the list then choose that item.
-	//
-	list.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-		if event.Key() == tcell.KeyEnter {
-			selected := list.GetCurrentItem()
-			ui.chosen, _ = list.GetItemText(selected)
-			app.Stop()
-		}
-		return event
-	})
-
 	//
 	// Create a filter input-view
 	//
-	inputField := tview.NewInputField().
+	ui.inputField = tview.NewInputField().
 		SetLabel("Filter: ").
 		SetDoneFunc(func(key tcell.Key) {
 			if key == tcell.KeyEnter {
 
 				// get the selected index
-				selected := list.GetCurrentItem()
+				selected := ui.list.GetCurrentItem()
 
 				// less than the entry count?
-				if list.GetItemCount() > 0 {
-					ui.chosen, _ = list.GetItemText(selected)
+				if ui.list.GetItemCount() > 0 {
+					ui.chosen, _ = ui.list.GetItemText(selected)
 				}
-				app.Stop()
+				ui.app.Stop()
 			}
 		})
 
 	//
 	// Setup the filter-function, to filter the list to
 	// only matches present in the input-field
 	//
-	inputField.SetAutocompleteFunc(func(currentText string) (entries []string) {
+	ui.inputField.SetAutocompleteFunc(func(currentText string) (entries []string) {
 		// Get text
 		input := strings.TrimSpace(currentText)
 
 		// empty? All items should be visible
 		if input == "" {
-			list.Clear()
+			ui.list.Clear()
 			for _, entry := range ui.Choices {
-				list.AddItem(entry, "", ' ', nil)
+				ui.list.AddItem(entry, "", ' ', nil)
 			}
 			return
 		}
 
 		// Otherwise filter by input
 		input = strings.ToLower(input)
-		list.Clear()
+		ui.list.Clear()
 		for _, entry := range ui.Choices {
 			if strings.Contains(strings.ToLower(entry), input) {
-				list.AddItem(entry, "", ' ', nil)
+				ui.list.AddItem(entry, "", ' ', nil)
 			}
 		}
 
@@ -120,64 +117,92 @@ func (ui *ChooseUI) Choose() string {
 	// Create a layout grid, add the filter-box and the list.
 	//
 	grid := tview.NewFlex().SetFullScreen(true).SetDirection(tview.FlexRow)
-	grid.AddItem(inputField, 1, 0, true)
-	grid.AddItem(list, 0, 1, false)
+	grid.AddItem(ui.inputField, 1, 0, true)
+	grid.AddItem(ui.list, 0, 1, false)
 	grid.AddItem(help, 2, 1, false)
 
+	ui.app.SetRoot(grid, true).SetFocus(grid).EnableMouse(true)
+
+}
+
+func (ui *ChooseUI) SetupKeyBinding() {
+
+	//
+	// If the user presses return in the list then choose that item.
+	//
+	ui.list.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+		if event.Key() == tcell.KeyEnter {
+			selected := ui.list.GetCurrentItem()
+			ui.chosen, _ = ui.list.GetItemText(selected)
+			ui.app.Stop()
+		}
+		return event
+	})
+
 	//
 	// Global keyboard handler, use "TAB" to switch focus.
 	//
 	// Arrows and HOME/END work as expected regardless of focus-state
 	//
-	app.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+	ui.app.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
 		switch event.Key() {
 
 		// Home
 		case tcell.KeyHome:
-			list.SetCurrentItem(0)
+			ui.list.SetCurrentItem(0)
 
 		// End
 		case tcell.KeyEnd:
-			list.SetCurrentItem(list.GetItemCount())
+			ui.list.SetCurrentItem(ui.list.GetItemCount())
 
 		// Up arrow
 		case tcell.KeyUp:
-			selected := list.GetCurrentItem()
+			selected := ui.list.GetCurrentItem()
 			if selected > 0 {
 				selected--
 			} else {
-				selected = list.GetItemCount()
+				selected = ui.list.GetItemCount()
 			}
-			list.SetCurrentItem(selected)
+			ui.list.SetCurrentItem(selected)
 			return nil
 
 		// Down arrow
 		case tcell.KeyDown:
-			selected := list.GetCurrentItem()
+			selected := ui.list.GetCurrentItem()
 			selected++
-			list.SetCurrentItem(selected)
+			ui.list.SetCurrentItem(selected)
 			return nil
 
 		// TAB
 		case tcell.KeyTab, tcell.KeyBacktab:
-			if list.HasFocus() {
-				app.SetFocus(inputField)
+			if ui.list.HasFocus() {
+				ui.app.SetFocus(ui.inputField)
 			} else {
-				app.SetFocus(list)
+				ui.app.SetFocus(ui.list)
 			}
 			return nil
 
 		// Escape
 		case tcell.KeyEscape:
-			app.Stop()
+			ui.app.Stop()
 		}
 		return event
 	})
 
+}
+
+// Choose launches our user interface.
+func (ui *ChooseUI) Choose() string {
+
+	ui.SetupUI()
+
+	ui.SetupKeyBinding()
+
 	//
 	// Launch the application.
 	//
-	if err := app.SetRoot(grid, true).SetFocus(grid).EnableMouse(true).Run(); err != nil {
+	err := ui.app.Run()
+	if err != nil {
 		panic(err)
 	}
 

cmd_feeds.go

@@ -54,8 +54,24 @@ func (t *feedsCommand) FindFeeds(base string) ([]string, error) {
 	// Get the body.
 	defer response.Body.Close()
 
+	// Create a parser
 	z := html.NewTokenizer(response.Body)
 
+	// Use the parser to get the links
+	ret, err = t.runparser(z, base)
+
+	// Nothing found?
+	if len(ret) == 0 {
+		return ret, ErrNoFeeds
+	}
+	return ret, nil
+}
+
+// runparser uses the given parser to look for feeds, and returns those it fouind
+func (t *feedsCommand) runparser(z *html.Tokenizer, base string) ([]string, error) {
+
+	ret := []string{}
+
 	for {
 		tt := z.Next()
 		switch tt {
@@ -92,11 +108,6 @@ func (t *feedsCommand) FindFeeds(base string) ([]string, error) {
 		}
 	}
 
-	// Nothing found?
-	if len(ret) == 0 {
-		return ret, ErrNoFeeds
-	}
-	return ret, nil
 }
 
 // Execute is invoked if the user specifies `feeds` as the subcommand.

cmd_todo.go

@@ -94,6 +94,67 @@ func (t *todoCommand) scanPath(path string) error {
 	return err
 }
 
+// processLine outputs any matching lines; those that contain a date and a TODO/FIXME reference.
+func (t *todoCommand) processLine(path string, line string) error {
+
+	// Does this line contain TODO, or FIXME?  If not return
+	if !strings.Contains(line, "TODO") && !strings.Contains(line, "FIXME") {
+		return nil
+	}
+
+	// remove leading/trailing space
+	line = strings.TrimSpace(line)
+
+	// Does it contain a date?
+	match := t.reg.FindStringSubmatch(line)
+
+	// OK we have a date.
+	if len(match) >= 2 {
+
+		// The date we've found
+		date := match[1]
+
+		var found time.Time
+		var err error
+
+		// Split by "/" to find the number
+		// of values we've got:
+		//
+		//   "DD/MM/YYYY"
+		//   "MM/YYYY"
+		//   "YYYY"
+		parts := strings.Split(date, "/")
+
+		switch len(parts) {
+		case 3:
+			found, err = time.Parse("02/01/2006", date)
+			if err != nil {
+				return fmt.Errorf("failed to parse %s:%s", date, err)
+			}
+		case 2:
+			found, err = time.Parse("01/2006", date)
+			if err != nil {
+				return fmt.Errorf("failed to parse %s:%s", date, err)
+			}
+		case 1:
+			found, err = time.Parse("2006", date)
+			if err != nil {
+				return fmt.Errorf("failed to parse %s:%s", date, err)
+			}
+		default:
+			return fmt.Errorf("unknown date-format %s", date)
+		}
+
+		// If the date we've parsed is before today
+		// then we alert on the line.
+		if found.Before(t.now) {
+			fmt.Printf("%s:%s\n", path, line)
+		}
+	}
+
+	return nil
+}
+
 // processFile opens a file and reads line by line for a date.
 func (t *todoCommand) processFile(path string) error {
 
@@ -129,60 +190,9 @@ func (t *todoCommand) processFile(path string) error {
 	// Process each line
 	for scanner.Scan() {
 
-		// The line we're operating upon.
-		line := scanner.Text()
-
-		// Does this line contain TODO, or FIXME?
-		if strings.Contains(line, "TODO") || strings.Contains(line, "FIXME") {
-
-			// remove leading/trailing space
-			line = strings.TrimSpace(line)
-
-			// Does it contain a date?
-			match := t.reg.FindStringSubmatch(line)
-
-			// OK we have a date.
-			if len(match) >= 2 {
-
-				// The date we've found
-				date := match[1]
-
-				var found time.Time
-
-				// Split by "/" to find the number
-				// of values we've got:
-				//
-				//   "DD/MM/YYYY"
-				//   "MM/YYYY"
-				//   "YYYY"
-				parts := strings.Split(date, "/")
-
-				switch len(parts) {
-				case 3:
-					found, err = time.Parse("02/01/2006", date)
-					if err != nil {
-						return fmt.Errorf("failed to parse %s:%s", date, err)
-					}
-				case 2:
-					found, _ = time.Parse("01/2006", date)
-					if err != nil {
-						return fmt.Errorf("failed to parse %s:%s", date, err)
-					}
-				case 1:
-					found, _ = time.Parse("2006", date)
-					if err != nil {
-						return fmt.Errorf("failed to parse %s:%s", date, err)
-					}
-				default:
-					return fmt.Errorf("unknown date-format %s", date)
-				}
-
-				// If the date we've parsed is before today
-				// then we alert on the line.
-				if found.Before(t.now) {
-					fmt.Printf("%s:%s\n", path, line)
-				}
-			}
+		err := t.processLine(path, scanner.Text())
+		if err != nil {
+			return err
 		}
 	}