From 934b09950149e0d5d2d3f083c818b6c1de04358d Mon Sep 17 00:00:00 2001 From: Trym Bremnes Date: Wed, 27 Mar 2024 09:28:39 +0100 Subject: [PATCH] refactor: rename variables in `console` package This commit renames the variables in `color.go`,`console.go`, `filter.go`, `listwidget.go`, `records.go`, `RecordWidget.go` and `shortcuthelpwidget.go` to make the code more readable. There are no logic changes. --- cmd/console/RecordWidget.go | 228 ++++++++++---------- cmd/console/color.go | 8 +- cmd/console/console.go | 123 ++++++----- cmd/console/filter.go | 102 ++++----- cmd/console/listwidget.go | 336 +++++++++++++++--------------- cmd/console/records.go | 98 ++++----- cmd/console/shortcuthelpwidget.go | 34 +-- 7 files changed, 464 insertions(+), 465 deletions(-) diff --git a/cmd/console/RecordWidget.go b/cmd/console/RecordWidget.go index cdbef9b7..4169c540 100644 --- a/cmd/console/RecordWidget.go +++ b/cmd/console/RecordWidget.go @@ -31,271 +31,271 @@ func NewRecordWidget(name, prev, next string) *RecordWidget { } } -func (w *RecordWidget) Layout(g *gocui.Gui) error { - maxX, maxY := g.Size() +func (recordWidget *RecordWidget) Layout(gui *gocui.Gui) error { + maxX, maxY := gui.Size() dynamicColumnWidth := maxX - 60 if dynamicColumnWidth < 51 { dynamicColumnWidth = 51 } - if v, err := g.SetView(w.headerView, 50, 10, dynamicColumnWidth, 30, gocui.BOTTOM|gocui.RIGHT); err != nil { + if view, err := gui.SetView(recordWidget.headerView, 50, 10, dynamicColumnWidth, 30, gocui.BOTTOM|gocui.RIGHT); err != nil { if err != gocui.ErrUnknownView { return err } - v.FgColor = gocui.ColorDefault - v.BgColor = gocui.ColorDefault - v.SelBgColor = gocui.ColorWhite - v.SelFgColor = gocui.ColorBlack - v.Highlight = false - v.Wrap = true - v.Title = "WARC header" + view.FgColor = gocui.ColorDefault + view.BgColor = gocui.ColorDefault + view.SelBgColor = gocui.ColorWhite + view.SelFgColor = gocui.ColorBlack + view.Highlight = false + view.Wrap = true + view.Title = "WARC header" } - if v, err := g.SetView(w.contentView, 50, 30, dynamicColumnWidth, maxY-2, gocui.TOP|gocui.RIGHT); err != nil { + if view, err := gui.SetView(recordWidget.contentView, 50, 30, dynamicColumnWidth, maxY-2, gocui.TOP|gocui.RIGHT); err != nil { if err != gocui.ErrUnknownView { return err } - v.FgColor = gocui.ColorDefault - v.BgColor = gocui.ColorDefault - v.SelBgColor = gocui.ColorWhite - v.SelFgColor = gocui.ColorBlack - v.Highlight = false - v.Wrap = true - v.Title = "WARC content" + view.FgColor = gocui.ColorDefault + view.BgColor = gocui.ColorDefault + view.SelBgColor = gocui.ColorWhite + view.SelFgColor = gocui.ColorBlack + view.Highlight = false + view.Wrap = true + view.Title = "WARC content" } - if v, err := g.SetView(w.errorView, dynamicColumnWidth, 10, maxX-1, maxY-2, gocui.LEFT); err != nil { + if view, err := gui.SetView(recordWidget.errorView, dynamicColumnWidth, 10, maxX-1, maxY-2, gocui.LEFT); err != nil { if err != gocui.ErrUnknownView { return err } - v.FgColor = gocui.ColorRed - v.BgColor = gocui.ColorDefault - v.SelBgColor = gocui.ColorWhite - v.SelFgColor = gocui.ColorBlack - v.Highlight = false - v.Wrap = true - v.Title = "Errors" + view.FgColor = gocui.ColorRed + view.BgColor = gocui.ColorDefault + view.SelBgColor = gocui.ColorWhite + view.SelFgColor = gocui.ColorBlack + view.Highlight = false + view.Wrap = true + view.Title = "Errors" } - _ = w.addKeybindings(g, w.headerView) - _ = w.addKeybindings(g, w.contentView) - _ = w.addKeybindings(g, w.errorView) + _ = recordWidget.addKeybindings(gui, recordWidget.headerView) + _ = recordWidget.addKeybindings(gui, recordWidget.contentView) + _ = recordWidget.addKeybindings(gui, recordWidget.errorView) return nil } -func (w *RecordWidget) addKeybindings(g *gocui.Gui, widget string) error { - if err := g.SetKeybinding(widget, gocui.KeyArrowDown, gocui.ModNone, w.cursorDown); err != nil { +func (recordWidget *RecordWidget) addKeybindings(gui *gocui.Gui, widget string) error { + if err := gui.SetKeybinding(widget, gocui.KeyArrowDown, gocui.ModNone, recordWidget.cursorDown); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.KeyArrowUp, gocui.ModNone, w.cursorUp); err != nil { + if err := gui.SetKeybinding(widget, gocui.KeyArrowUp, gocui.ModNone, recordWidget.cursorUp); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.KeyHome, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { + if err := gui.SetKeybinding(widget, gocui.KeyHome, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { if view != nil { - return w.scroll(view, -view.ViewLinesHeight()) + return recordWidget.scroll(view, -view.ViewLinesHeight()) } return nil }); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.KeyEnd, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { + if err := gui.SetKeybinding(widget, gocui.KeyEnd, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { if view != nil { - return w.scroll(view, view.ViewLinesHeight()) + return recordWidget.scroll(view, view.ViewLinesHeight()) } return nil }); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.KeyPgdn, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { + if err := gui.SetKeybinding(widget, gocui.KeyPgdn, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { if view != nil { _, h := view.Size() h-- - return w.scroll(view, h) + return recordWidget.scroll(view, h) } return nil }); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.KeyPgup, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { + if err := gui.SetKeybinding(widget, gocui.KeyPgup, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { if view != nil { _, h := view.Size() h-- - return w.scroll(view, -h) + return recordWidget.scroll(view, -h) } return nil }); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.MouseWheelDown, gocui.ModNone, w.cursorDown); err != nil { + if err := gui.SetKeybinding(widget, gocui.MouseWheelDown, gocui.ModNone, recordWidget.cursorDown); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.MouseWheelUp, gocui.ModNone, w.cursorUp); err != nil { + if err := gui.SetKeybinding(widget, gocui.MouseWheelUp, gocui.ModNone, recordWidget.cursorUp); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.KeyEnter, gocui.ModNone, w.nextView); err != nil { + if err := gui.SetKeybinding(widget, gocui.KeyEnter, gocui.ModNone, recordWidget.nextView); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.KeyEsc, gocui.ModNone, w.prevView); err != nil { + if err := gui.SetKeybinding(widget, gocui.KeyEsc, gocui.ModNone, recordWidget.prevView); err != nil { return err } - if err := g.SetKeybinding(widget, gocui.MouseLeft, gocui.ModNone, w.currentView); err != nil { + if err := gui.SetKeybinding(widget, gocui.MouseLeft, gocui.ModNone, recordWidget.currentView); err != nil { return err } return nil } -func (w *RecordWidget) readRecord(g *gocui.Gui, widget *ListWidget) { - r, err := gowarc.NewWarcFileReader(state.dir+"/"+state.file, widget.filteredRecords[widget.selected].(record).offset, +func (recordWidget *RecordWidget) readRecord(gui *gocui.Gui, widget *ListWidget) { + warcFileReader, err := gowarc.NewWarcFileReader(state.dir+"/"+state.file, widget.filteredRecords[widget.selected].(record).offset, gowarc.WithBufferTmpDir(viper.GetString(flag.TmpDir))) if err != nil { panic(err) } - defer func() { _ = r.Close() }() + defer func() { _ = warcFileReader.Close() }() - rec, offset, val, err := r.Next() + warcRecord, offset, validation, err := warcFileReader.Next() if err != nil { panic(err) } - defer func() { _ = rec.Close() }() + defer func() { _ = warcRecord.Close() }() - w.poopulateHeader(g, rec, offset) - w.poopulateContent(g, rec) + recordWidget.poopulateHeader(gui, warcRecord, offset) + recordWidget.poopulateContent(gui, warcRecord) - if err := rec.ValidateDigest(val); err != nil { - *val = append(*val, err) + if err := warcRecord.ValidateDigest(validation); err != nil { + *validation = append(*validation, err) } - if err := rec.Close(); err != nil { - *val = append(*val, err) + if err := warcRecord.Close(); err != nil { + *validation = append(*validation, err) } - ev, err := g.View(w.errorView) + view, err := gui.View(recordWidget.errorView) if err != nil { panic(err) } - ev.Clear() - _, _ = fmt.Fprintf(ev, "%s\n", val) + view.Clear() + _, _ = fmt.Fprintf(view, "%s\n", validation) } -func (w *RecordWidget) poopulateHeader(g *gocui.Gui, rec gowarc.WarcRecord, offset int64) { - view, err := g.View(w.headerView) +func (recordWidget *RecordWidget) poopulateHeader(gui *gocui.Gui, warcRecord gowarc.WarcRecord, offset int64) { + view, err := gui.View(recordWidget.headerView) if err != nil { panic(err) } view.Clear() view.Subtitle = fmt.Sprintf("Offset: %d", offset) - f := &visibleLineEndingFilter{view} - _, _ = f.Write([]byte(rec.Version().String() + "\r\n")) - _, _ = rec.WarcHeader().Write(f) + visibleLineEndingFilter := &visibleLineEndingFilter{view} + _, _ = visibleLineEndingFilter.Write([]byte(warcRecord.Version().String() + "\r\n")) + _, _ = warcRecord.WarcHeader().Write(visibleLineEndingFilter) } -func (w *RecordWidget) poopulateContent(g *gocui.Gui, rec gowarc.WarcRecord) { - view, err := g.View(w.contentView) +func (recordWidget *RecordWidget) poopulateContent(gui *gocui.Gui, warcRecord gowarc.WarcRecord) { + view, err := gui.View(recordWidget.contentView) if err != nil { panic(err) } view.Clear() - if _, ok := rec.Block().(gowarc.PayloadBlock); ok { + if _, ok := warcRecord.Block().(gowarc.PayloadBlock); ok { // Cache block when there is a defined payload so that we can get the payload size later. - _ = rec.Block().Cache() + _ = warcRecord.Block().Cache() } - f := &visibleLineEndingFilter{view} - rr, err := rec.Block().RawBytes() + visibleLineEndingFilter := &visibleLineEndingFilter{view} + ioReader, err := warcRecord.Block().RawBytes() if err != nil { panic(err) } - content, err := io.ReadAll(rr) + content, err := io.ReadAll(ioReader) if err != nil { panic(err) } - _, _ = f.Write(content) + _, _ = visibleLineEndingFilter.Write(content) subtitle := fmt.Sprintf("Blocksize: %d", len(content)) - if p, ok := rec.Block().(gowarc.PayloadBlock); ok { - rr, err := p.PayloadBytes() + if payloadblock, ok := warcRecord.Block().(gowarc.PayloadBlock); ok { + ioReader, err := payloadblock.PayloadBytes() if err != nil { panic(err) } - n, err := io.Copy(io.Discard, rr) + bytesWritten, err := io.Copy(io.Discard, ioReader) if err != nil { panic(err) } - subtitle = fmt.Sprintf("%s, PayloadSize: %d", subtitle, n) + subtitle = fmt.Sprintf("%s, PayloadSize: %d", subtitle, bytesWritten) } view.Subtitle = subtitle } type visibleLineEndingFilter struct { - w io.Writer + ioWriter io.Writer } -func (f *visibleLineEndingFilter) Write(p []byte) (n int, err error) { - p = colorizeReplaceAll(p, []byte("\r"), []byte("\\r")) - p = colorizeReplaceAll(p, []byte("\n"), []byte("\\n\n")) - return f.w.Write(p) +func (visiblelineEndingFilter *visibleLineEndingFilter) Write(content []byte) (bytesWritten int, err error) { + content = colorizeReplaceAll(content, []byte("\r"), []byte("\\r")) + content = colorizeReplaceAll(content, []byte("\n"), []byte("\\n\n")) + return visiblelineEndingFilter.ioWriter.Write(content) } func colorizeReplaceAll(source, old, replacement []byte) []byte { reset := escapeFgColor(gocui.ColorDefault) - v := fmt.Sprintf("%s%s%s", escapeFgColor(gocui.ColorGreen), replacement, reset) - return bytes.ReplaceAll(source, old, []byte(v)) + coloredString := fmt.Sprintf("%s%s%s", escapeFgColor(gocui.ColorGreen), replacement, reset) + return bytes.ReplaceAll(source, old, []byte(coloredString)) } -func (w *RecordWidget) cursorDown(g *gocui.Gui, v *gocui.View) error { - return w.scroll(v, 1) +func (recordWidget *RecordWidget) cursorDown(gui *gocui.Gui, view *gocui.View) error { + return recordWidget.scroll(view, 1) } -func (w *RecordWidget) cursorUp(g *gocui.Gui, v *gocui.View) error { - return w.scroll(v, -1) +func (recordWidget *RecordWidget) cursorUp(gui *gocui.Gui, view *gocui.View) error { + return recordWidget.scroll(view, -1) } -func (w *RecordWidget) scroll(v *gocui.View, delta int) error { - if v != nil { - _, viewHeight := v.Size() - contentHeight := v.ViewLinesHeight() +func (recordWidget *RecordWidget) scroll(view *gocui.View, ScrollDelta int) error { + if view != nil { + _, viewHeight := view.Size() + contentHeight := view.ViewLinesHeight() if viewHeight >= contentHeight { return nil } - ox, oy := v.Origin() - ny := oy + delta - if ny < 0 { - ny = 0 + originX, originY := view.Origin() + scrollDestinationY := originY + ScrollDelta + if scrollDestinationY < 0 { + scrollDestinationY = 0 } - if contentHeight-viewHeight < ny { - ny = contentHeight - viewHeight + if contentHeight-viewHeight < scrollDestinationY { + scrollDestinationY = contentHeight - viewHeight } - _ = v.SetOrigin(ox, ny) + _ = view.SetOrigin(originX, scrollDestinationY) } return nil } -func (w *RecordWidget) prevView(g *gocui.Gui, v *gocui.View) error { +func (recordWidget *RecordWidget) prevView(gui *gocui.Gui, view *gocui.View) error { switch state.curView { - case w.errorView: - state.curView = w.contentView - case w.contentView: - state.curView = w.headerView - case w.headerView: - state.curView = w.prev + case recordWidget.errorView: + state.curView = recordWidget.contentView + case recordWidget.contentView: + state.curView = recordWidget.headerView + case recordWidget.headerView: + state.curView = recordWidget.prev } return nil } -func (w *RecordWidget) nextView(g *gocui.Gui, v *gocui.View) error { +func (recordWidget *RecordWidget) nextView(gui *gocui.Gui, view *gocui.View) error { switch state.curView { - case w.headerView: - state.curView = w.contentView - case w.contentView: - state.curView = w.errorView - case w.errorView: - state.curView = w.next + case recordWidget.headerView: + state.curView = recordWidget.contentView + case recordWidget.contentView: + state.curView = recordWidget.errorView + case recordWidget.errorView: + state.curView = recordWidget.next } return nil } -func (w *RecordWidget) currentView(g *gocui.Gui, v *gocui.View) error { - state.curView = v.Name() +func (recordWidget *RecordWidget) currentView(gui *gocui.Gui, view *gocui.View) error { + state.curView = view.Name() return nil } diff --git a/cmd/console/color.go b/cmd/console/color.go index 699bef33..b438b034 100644 --- a/cmd/console/color.go +++ b/cmd/console/color.go @@ -22,14 +22,14 @@ func escapeFgColor(color gocui.Attribute) string { if color == gocui.ColorDefault { return "\x1b[0m" } - ir, ig, ib := color.RGB() - return fmt.Sprintf("\x1b[38;2;%d;%d;%dm", ir, ig, ib) + red, green, blue := color.RGB() + return fmt.Sprintf("\x1b[38;2;%d;%d;%dm", red, green, blue) } func escapeBgColor(color gocui.Attribute) string { if color == gocui.ColorDefault { return "\x1b[0m" } - ir, ig, ib := color.RGB() - return fmt.Sprintf("\x1b[48;2;%d;%d;%dm", ir, ig, ib) + red, green, blue := color.RGB() + return fmt.Sprintf("\x1b[48;2;%d;%d;%dm", red, green, blue) } diff --git a/cmd/console/console.go b/cmd/console/console.go index 53dbd118..f3144b6b 100644 --- a/cmd/console/console.go +++ b/cmd/console/console.go @@ -39,15 +39,14 @@ func parseArgumentsAndCallConsole(cmd *cobra.Command, args []string) error { if state.dir, err = filepath.EvalSymlinks(state.dir); err != nil { return err } - var f os.FileInfo - f, err = os.Lstat(state.dir) + var fileInfo os.FileInfo + fileInfo, err = os.Lstat(state.dir) if err != nil { return err } - if !f.IsDir() { - f := path.Base(state.dir) + if !fileInfo.IsDir() { state.dir = path.Dir(state.dir) - state.files = append(state.files, f) + state.files = append(state.files, path.Base(state.dir)) } if state.suffixes, err = cmd.Flags().GetStringSlice(flag.Suffixes); err != nil { return err @@ -61,26 +60,26 @@ var state = &State{curView: "dir"} func runE() error { os.Setenv("COLORTERM", "truecolor") - g, err := gocui.NewGui(gocui.OutputTrue, true) + gui, err := gocui.NewGui(gocui.OutputTrue, true) if err != nil { log.Panicln(err) } - defer g.Close() + defer gui.Close() - state.g = g + state.gui = gui - g.Cursor = false - g.Highlight = true - g.FgColor = gocui.ColorYellow - g.BgColor = gocui.ColorDefault - g.SelFgColor = gocui.ColorCyan - g.SelBgColor = gocui.ColorDefault - g.SelFrameColor = gocui.ColorCyan - g.SupportOverlaps = true - g.Mouse = true + gui.Cursor = false + gui.Highlight = true + gui.FgColor = gocui.ColorYellow + gui.BgColor = gocui.ColorDefault + gui.SelFgColor = gocui.ColorCyan + gui.SelBgColor = gocui.ColorDefault + gui.SelFrameColor = gocui.ColorCyan + gui.SupportOverlaps = true + gui.Mouse = true nonWidgets := gocui.ManagerFunc(layout) - fl := gocui.ManagerFunc(flowLayout) + flowLayout := gocui.ManagerFunc(flowLayout) filesWidget := NewListWidget("dir", "Content_error", "Records", readFile, populateFiles) @@ -90,61 +89,61 @@ func runE() error { state.filter = &recordFilter{} recordsWidget.filterFunc = state.filter.filterFunc - g.SetManager(filesWidget, recordsWidget, viewRecordWidget, nonWidgets, fl) + gui.SetManager(filesWidget, recordsWidget, viewRecordWidget, nonWidgets, flowLayout) - if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil { + if err := gui.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 'e', gocui.ModNone, state.filter.toggleErrorFilter); err != nil { + if err := gui.SetKeybinding("", 'e', gocui.ModNone, state.filter.toggleErrorFilter); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("help", gocui.MouseLeft, gocui.ModNone, state.filter.mouseToggleFilter); err != nil { + if err := gui.SetKeybinding("help", gocui.MouseLeft, gocui.ModNone, state.filter.mouseToggleFilter); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 'i', gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { - return state.filter.toggleRecordTypeFilter(g, gowarc.Warcinfo) + if err := gui.SetKeybinding("", 'i', gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { + return state.filter.toggleRecordTypeFilter(gui, gowarc.Warcinfo) }); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 'q', gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { - return state.filter.toggleRecordTypeFilter(g, gowarc.Request) + if err := gui.SetKeybinding("", 'q', gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { + return state.filter.toggleRecordTypeFilter(gui, gowarc.Request) }); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 'r', gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { - return state.filter.toggleRecordTypeFilter(g, gowarc.Response) + if err := gui.SetKeybinding("", 'r', gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { + return state.filter.toggleRecordTypeFilter(gui, gowarc.Response) }); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 'm', gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { - return state.filter.toggleRecordTypeFilter(g, gowarc.Metadata) + if err := gui.SetKeybinding("", 'm', gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { + return state.filter.toggleRecordTypeFilter(gui, gowarc.Metadata) }); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 's', gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { - return state.filter.toggleRecordTypeFilter(g, gowarc.Resource) + if err := gui.SetKeybinding("", 's', gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { + return state.filter.toggleRecordTypeFilter(gui, gowarc.Resource) }); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 'v', gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { - return state.filter.toggleRecordTypeFilter(g, gowarc.Revisit) + if err := gui.SetKeybinding("", 'v', gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { + return state.filter.toggleRecordTypeFilter(gui, gowarc.Revisit) }); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 'c', gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { - return state.filter.toggleRecordTypeFilter(g, gowarc.Continuation) + if err := gui.SetKeybinding("", 'c', gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { + return state.filter.toggleRecordTypeFilter(gui, gowarc.Continuation) }); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 'n', gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { - return state.filter.toggleRecordTypeFilter(g, gowarc.Conversion) + if err := gui.SetKeybinding("", 'n', gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { + return state.filter.toggleRecordTypeFilter(gui, gowarc.Conversion) }); err != nil { log.Panicln(err) } - if err := g.SetKeybinding("", 'h', gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { - v := NewShortcutHelpWidget() - return v.Layout(g) + if err := gui.SetKeybinding("", 'h', gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { + shortcutHelpWidget := NewShortcutHelpWidget() + return shortcutHelpWidget.Layout(gui) }); err != nil { log.Panicln(err) } @@ -159,22 +158,22 @@ func runE() error { } } time.AfterFunc(100*time.Millisecond, func() { - filesWidget.Init(g, state.dir) + filesWidget.Init(gui, state.dir) }) - if err := g.MainLoop(); err != nil && !errors.Is(err, gocui.ErrQuit) { + if err := gui.MainLoop(); err != nil && !errors.Is(err, gocui.ErrQuit) { panic(err) } return nil } -func flowLayout(g *gocui.Gui) error { - maxX, maxY := g.Size() - views := g.Views() +func flowLayout(gui *gocui.Gui) error { + maxX, maxY := gui.Size() + views := gui.Views() - for _, v := range views { + for _, view := range views { var x0, y0, x1, y1 int - switch v.Name() { + switch view.Name() { case "Records": x0 = 0 y0 = 10 @@ -188,7 +187,7 @@ func flowLayout(g *gocui.Gui) error { default: continue } - _, err := g.SetView(v.Name(), x0, y0, x1, y1, 0) + _, err := gui.SetView(view.Name(), x0, y0, x1, y1, 0) if err != nil && !errors.Is(err, gocui.ErrUnknownView) { return err } @@ -196,42 +195,42 @@ func flowLayout(g *gocui.Gui) error { return nil } -func layout(g *gocui.Gui) error { - maxX, maxY := g.Size() +func layout(gui *gocui.Gui) error { + maxX, maxY := gui.Size() - if v, err := g.SetView("help", 0, maxY-2, maxX, maxY, 0); err != nil { + if view, err := gui.SetView("help", 0, maxY-2, maxX, maxY, 0); err != nil { if err != gocui.ErrUnknownView { return err } - v.Frame = false - v.Editable = false + view.Frame = false + view.Editable = false } - state.filter.refreshHelp(g) + state.filter.refreshHelp(gui) - v := state.curView + newView := state.curView if state.modalView != "" { - v = state.modalView + newView = state.modalView } - if _, err := g.SetCurrentView(v); err != nil { + if _, err := gui.SetCurrentView(newView); err != nil { return err } return nil } -func quit(g *gocui.Gui, v *gocui.View) error { +func quit(gui *gocui.Gui, v *gocui.View) error { return gocui.ErrQuit } -func readFile(g *gocui.Gui, widget *ListWidget) { +func readFile(gui *gocui.Gui, widget *ListWidget) { if len(widget.filteredRecords) > 0 { state.file = widget.filteredRecords[widget.selected].(string) - state.records.Init(g, state.dir+"/"+state.file) + state.records.Init(gui, state.dir+"/"+state.file) } } type State struct { - g *gocui.Gui + gui *gocui.Gui curView string modalView string suffixes []string diff --git a/cmd/console/filter.go b/cmd/console/filter.go index f0b0808f..ea8e6f73 100644 --- a/cmd/console/filter.go +++ b/cmd/console/filter.go @@ -13,25 +13,25 @@ type recordFilter struct { recType gowarc.RecordType } -func (r *recordFilter) filterFunc(rec interface{}) bool { +func (recordfilter *recordFilter) filterFunc(rec interface{}) bool { if rec == nil { return false } - if !r.error && r.recType == 0 { + if !recordfilter.error && recordfilter.recType == 0 { return true } - if r.error && rec.(record).hasError { + if recordfilter.error && rec.(record).hasError { return true } - if r.recType&rec.(record).recordType != 0 { + if recordfilter.recType&rec.(record).recordType != 0 { return true } return false } -func (r *recordFilter) mouseToggleFilter(g *gocui.Gui, v *gocui.View) error { - x, y := v.Cursor() - str, _ := v.Line(y) +func (recordfilter *recordFilter) mouseToggleFilter(gui *gocui.Gui, view *gocui.View) error { + x, y := view.Cursor() + str, _ := view.Line(y) nl := strings.LastIndexFunc(str[:x], indexFunc) if nl == -1 { @@ -49,79 +49,79 @@ func (r *recordFilter) mouseToggleFilter(g *gocui.Gui, v *gocui.View) error { switch strings.ToLower(word) { case "error": - _ = r.toggleErrorFilter(g, v) + _ = recordfilter.toggleErrorFilter(gui, view) case "warcinfo": - _ = r.toggleRecordTypeFilter(g, gowarc.Warcinfo) + _ = recordfilter.toggleRecordTypeFilter(gui, gowarc.Warcinfo) case "request": - _ = r.toggleRecordTypeFilter(g, gowarc.Request) + _ = recordfilter.toggleRecordTypeFilter(gui, gowarc.Request) case "response": - _ = r.toggleRecordTypeFilter(g, gowarc.Response) + _ = recordfilter.toggleRecordTypeFilter(gui, gowarc.Response) case "metadata": - _ = r.toggleRecordTypeFilter(g, gowarc.Metadata) + _ = recordfilter.toggleRecordTypeFilter(gui, gowarc.Metadata) case "revisit": - _ = r.toggleRecordTypeFilter(g, gowarc.Revisit) + _ = recordfilter.toggleRecordTypeFilter(gui, gowarc.Revisit) case "resource": - _ = r.toggleRecordTypeFilter(g, gowarc.Resource) + _ = recordfilter.toggleRecordTypeFilter(gui, gowarc.Resource) case "continuation": - _ = r.toggleRecordTypeFilter(g, gowarc.Continuation) + _ = recordfilter.toggleRecordTypeFilter(gui, gowarc.Continuation) case "conversion": - _ = r.toggleRecordTypeFilter(g, gowarc.Conversion) + _ = recordfilter.toggleRecordTypeFilter(gui, gowarc.Conversion) } return nil } -func indexFunc(r rune) bool { - return r == ' ' || r == 0 || r == '|' +func indexFunc(recordfilter rune) bool { + return recordfilter == ' ' || recordfilter == 0 || recordfilter == '|' } -func (r *recordFilter) toggleErrorFilter(g *gocui.Gui, v *gocui.View) error { - r.error = !r.error - v2, err := g.View("Records") +func (recordfilter *recordFilter) toggleErrorFilter(gui *gocui.Gui, view *gocui.View) error { + recordfilter.error = !recordfilter.error + recordView, err := gui.View("Records") if err != nil { return err } - r.refreshHelp(g) - return state.records.refreshFilter(g, v2) + recordfilter.refreshHelp(gui) + return state.records.refreshFilter(gui, recordView) } -func (r *recordFilter) toggleRecordTypeFilter(g *gocui.Gui, recType gowarc.RecordType) error { - r.recType = r.recType ^ recType - v2, err := g.View("Records") +func (recordfilter *recordFilter) toggleRecordTypeFilter(gui *gocui.Gui, recType gowarc.RecordType) error { + recordfilter.recType = recordfilter.recType ^ recType + recordView, err := gui.View("Records") if err != nil { return err } - r.refreshHelp(g) - return state.records.refreshFilter(g, v2) + recordfilter.refreshHelp(gui) + return state.records.refreshFilter(gui, recordView) } -func (r *recordFilter) refreshHelp(g *gocui.Gui) { - sb := strings.Builder{} - sb.WriteString("|") - sb.WriteString(filterString("Error", ErrorColor, r.error)) - sb.WriteString(filterString("warcInfo", WarcInfoColor, r.recType&gowarc.Warcinfo != 0)) - sb.WriteString(filterString("reQuest", RequestColor, r.recType&gowarc.Request != 0)) - sb.WriteString(filterString("Response", ResponseColor, r.recType&gowarc.Response != 0)) - sb.WriteString(filterString("Metadata", MetadataColor, r.recType&gowarc.Metadata != 0)) - sb.WriteString(filterString("reVisit", RevisitColor, r.recType&gowarc.Revisit != 0)) - sb.WriteString(filterString("reSource", ResourceColor, r.recType&gowarc.Resource != 0)) - sb.WriteString(filterString("Continuation", ContinuationColor, r.recType&gowarc.Continuation != 0)) - sb.WriteString(filterString("coNversion", ConversionColor, r.recType&gowarc.Conversion != 0)) - if v, err := g.View("help"); err == nil { - v.Clear() - txt := "h: help" - width, _ := v.Size() +func (recordfilter *recordFilter) refreshHelp(gui *gocui.Gui) { + toolbarString := strings.Builder{} + toolbarString.WriteString("|") + toolbarString.WriteString(filterString("Error", ErrorColor, recordfilter.error)) + toolbarString.WriteString(filterString("warcInfo", WarcInfoColor, recordfilter.recType&gowarc.Warcinfo != 0)) + toolbarString.WriteString(filterString("reQuest", RequestColor, recordfilter.recType&gowarc.Request != 0)) + toolbarString.WriteString(filterString("Response", ResponseColor, recordfilter.recType&gowarc.Response != 0)) + toolbarString.WriteString(filterString("Metadata", MetadataColor, recordfilter.recType&gowarc.Metadata != 0)) + toolbarString.WriteString(filterString("reVisit", RevisitColor, recordfilter.recType&gowarc.Revisit != 0)) + toolbarString.WriteString(filterString("reSource", ResourceColor, recordfilter.recType&gowarc.Resource != 0)) + toolbarString.WriteString(filterString("Continuation", ContinuationColor, recordfilter.recType&gowarc.Continuation != 0)) + toolbarString.WriteString(filterString("coNversion", ConversionColor, recordfilter.recType&gowarc.Conversion != 0)) + if view, err := gui.View("help"); err == nil { + view.Clear() + helpText := "h: help" + width, _ := view.Size() space := width - 85 - fmt.Fprintf(v, "%[1]s%[2]*[3]s", sb.String(), space, txt) + fmt.Fprintf(view, "%[1]s%[2]*[3]s", toolbarString.String(), space, helpText) } } -func filterString(s string, color gocui.Attribute, on bool) string { - fg := escapeFgColor(gocui.NewRGBColor(0, 0, 0)) - bg := escapeBgColor(gocui.NewRGBColor(0, 0, 0)) - if on { - return fmt.Sprintf("%s%s%s%s|", escapeBgColor(color), fg, s, escapeFgColor(gocui.ColorDefault)) +func filterString(s string, color gocui.Attribute, enabled bool) string { + foreground := escapeFgColor(gocui.NewRGBColor(0, 0, 0)) + background := escapeBgColor(gocui.NewRGBColor(0, 0, 0)) + if enabled { + return fmt.Sprintf("%s%s%s%s|", escapeBgColor(color), foreground, s, escapeFgColor(gocui.ColorDefault)) } else { - return fmt.Sprintf("%s%s%s%s|", escapeFgColor(color), bg, s, escapeFgColor(gocui.ColorDefault)) + return fmt.Sprintf("%s%s%s%s|", escapeFgColor(color), background, s, escapeFgColor(gocui.ColorDefault)) } } diff --git a/cmd/console/listwidget.go b/cmd/console/listwidget.go index 26e897d5..1810ee5c 100644 --- a/cmd/console/listwidget.go +++ b/cmd/console/listwidget.go @@ -20,8 +20,8 @@ type ListWidget struct { prev string next string selected int - selectFunc func(g *gocui.Gui, widget *ListWidget) - populateRecordsFunc func(g *gocui.Gui, ctx context.Context, finishedCb func(), widget *ListWidget, data interface{}) + selectFunc func(gui *gocui.Gui, widget *ListWidget) + populateRecordsFunc func(gui *gocui.Gui, ctx context.Context, finishedCb func(), widget *ListWidget, data interface{}) filterFunc func(interface{}) bool records []interface{} filteredRecords []interface{} @@ -32,8 +32,8 @@ type ListWidget struct { } func NewListWidget(name string, prev, next string, - selectFunc func(g *gocui.Gui, widget *ListWidget), - populateRecordsFunc func(g *gocui.Gui, ctx context.Context, finishedCb func(), widget *ListWidget, data interface{})) *ListWidget { + selectFunc func(gui *gocui.Gui, widget *ListWidget), + populateRecordsFunc func(gui *gocui.Gui, ctx context.Context, finishedCb func(), widget *ListWidget, data interface{})) *ListWidget { return &ListWidget{ name: name, @@ -45,277 +45,277 @@ func NewListWidget(name string, prev, next string, } } -func (w *ListWidget) Init(g *gocui.Gui, data interface{}) { - if w.cancelFunc != nil { - w.cancelRefreshFunc() - w.cancelRefreshFunc = nil - w.cancelFunc() - w.cancelFunc = nil - <-w.finished.Done() - w.finished = nil +func (widgetList *ListWidget) Init(gui *gocui.Gui, data interface{}) { + if widgetList.cancelFunc != nil { + widgetList.cancelRefreshFunc() + widgetList.cancelRefreshFunc = nil + widgetList.cancelFunc() + widgetList.cancelFunc = nil + <-widgetList.finished.Done() + widgetList.finished = nil } ctx, cancel := context.WithCancel(context.Background()) - w.cancelFunc = cancel + widgetList.cancelFunc = cancel var finishedCb func() var refreshCtx context.Context - refreshCtx, w.cancelRefreshFunc = context.WithCancel(context.Background()) - w.finished, finishedCb = context.WithCancel(context.Background()) - w.records = nil - w.filteredRecords = nil - w.selected = -1 + refreshCtx, widgetList.cancelRefreshFunc = context.WithCancel(context.Background()) + widgetList.finished, finishedCb = context.WithCancel(context.Background()) + widgetList.records = nil + widgetList.filteredRecords = nil + widgetList.selected = -1 go func() { - w.populateRecordsFunc(g, ctx, finishedCb, w, data) + widgetList.populateRecordsFunc(gui, ctx, finishedCb, widgetList, data) }() - w.update(g, refreshCtx, w.finished) + widgetList.update(gui, refreshCtx, widgetList.finished) } -func (w *ListWidget) Layout(g *gocui.Gui) error { - if v, err := g.SetView(w.name, 0, 0, 1, 1, 0); err != nil { +func (widgetList *ListWidget) Layout(gui *gocui.Gui) error { + if view, err := gui.SetView(widgetList.name, 0, 0, 1, 1, 0); err != nil { if err != gocui.ErrUnknownView { return err } - v.FgColor = gocui.ColorGreen - v.BgColor = gocui.ColorDefault - v.SelBgColor = gocui.ColorWhite - v.SelFgColor = gocui.ColorBlack - v.Highlight = false - v.Autoscroll = false - v.Title = w.name + view.FgColor = gocui.ColorGreen + view.BgColor = gocui.ColorDefault + view.SelBgColor = gocui.ColorWhite + view.SelFgColor = gocui.ColorBlack + view.Highlight = false + view.Autoscroll = false + view.Title = widgetList.name } - if err := g.SetKeybinding(w.name, gocui.KeyArrowDown, gocui.ModNone, w.cursorDown); err != nil { + if err := gui.SetKeybinding(widgetList.name, gocui.KeyArrowDown, gocui.ModNone, widgetList.cursorDown); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.KeyArrowUp, gocui.ModNone, w.cursorUp); err != nil { + if err := gui.SetKeybinding(widgetList.name, gocui.KeyArrowUp, gocui.ModNone, widgetList.cursorUp); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.KeyHome, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { + if err := gui.SetKeybinding(widgetList.name, gocui.KeyHome, gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { if view != nil { - return w.selectLine(g, view, 0) + return widgetList.selectLine(gui, view, 0) } return nil }); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.KeyEnd, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { + if err := gui.SetKeybinding(widgetList.name, gocui.KeyEnd, gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { if view != nil { - return w.selectLine(g, view, len(w.filteredRecords)-1) + return widgetList.selectLine(gui, view, len(widgetList.filteredRecords)-1) } return nil }); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.KeyPgdn, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { + if err := gui.SetKeybinding(widgetList.name, gocui.KeyPgdn, gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { if view != nil { - _, h := view.Size() - h-- - return w.selectLine(g, view, w.selected+h) + _, height := view.Size() + height-- + return widgetList.selectLine(gui, view, widgetList.selected+height) } return nil }); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.KeyPgup, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { + if err := gui.SetKeybinding(widgetList.name, gocui.KeyPgup, gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { if view != nil { - _, h := view.Size() - h-- - return w.selectLine(g, view, w.selected-h) + _, height := view.Size() + height-- + return widgetList.selectLine(gui, view, widgetList.selected-height) } return nil }); err != nil { return err } - if err := g.SetKeybinding(w.name, 'f', gocui.ModNone, w.search); err != nil { + if err := gui.SetKeybinding(widgetList.name, 'f', gocui.ModNone, widgetList.search); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.KeyEnter, gocui.ModNone, w.nextView); err != nil { + if err := gui.SetKeybinding(widgetList.name, gocui.KeyEnter, gocui.ModNone, widgetList.nextView); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.KeyEsc, gocui.ModNone, w.prevView); err != nil { + if err := gui.SetKeybinding(widgetList.name, gocui.KeyEsc, gocui.ModNone, widgetList.prevView); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.MouseLeft, gocui.ModNone, w.currentView); err != nil { + if err := gui.SetKeybinding(widgetList.name, gocui.MouseLeft, gocui.ModNone, widgetList.currentView); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.MouseRelease, gocui.ModNone, func(gui *gocui.Gui, view *gocui.View) error { + if err := gui.SetKeybinding(widgetList.name, gocui.MouseRelease, gocui.ModNone, func(guiInner *gocui.Gui, view *gocui.View) error { return nil }); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.MouseWheelDown, gocui.ModNone, w.cursorDown); err != nil { + if err := gui.SetKeybinding(widgetList.name, gocui.MouseWheelDown, gocui.ModNone, widgetList.cursorDown); err != nil { return err } - if err := g.SetKeybinding(w.name, gocui.MouseWheelUp, gocui.ModNone, w.cursorUp); err != nil { + if err := gui.SetKeybinding(widgetList.name, gocui.MouseWheelUp, gocui.ModNone, widgetList.cursorUp); err != nil { return err } return nil } -func (w *ListWidget) search(g *gocui.Gui, parent *gocui.View) error { - maxX, maxY := g.Size() - var v *gocui.View +func (widgetList *ListWidget) search(gui *gocui.Gui, parent *gocui.View) error { + maxX, maxY := gui.Size() + var view *gocui.View var err error - if v, err = g.SetView("search", maxX/2-35, maxY/2-1, maxX/2+35, maxY/2+1, 0); err != nil { + if view, err = gui.SetView("search", maxX/2-35, maxY/2-1, maxX/2+35, maxY/2+1, 0); err != nil { if err != gocui.ErrUnknownView { return err } - v.FgColor = gocui.ColorDefault - v.BgColor = gocui.ColorDefault - v.SelBgColor = gocui.ColorWhite - v.SelFgColor = gocui.ColorBlack - v.Highlight = false - v.Autoscroll = false - v.Title = "Find in " + parent.Title - v.FrameRunes = []rune{'═', '║', '╔', '╗', '╚', '╝'} - v.Editable = true - v.KeybindOnEdit = false - v.Editor = &SearchEditor{g, w, parent} - g.Cursor = true + view.FgColor = gocui.ColorDefault + view.BgColor = gocui.ColorDefault + view.SelBgColor = gocui.ColorWhite + view.SelFgColor = gocui.ColorBlack + view.Highlight = false + view.Autoscroll = false + view.Title = "Find in " + parent.Title + view.FrameRunes = []rune{'═', '║', '╔', '╗', '╚', '╝'} + view.Editable = true + view.KeybindOnEdit = false + view.Editor = &SearchEditor{gui, widgetList, parent} + gui.Cursor = true } state.modalView = "search" return nil } type SearchEditor struct { - g *gocui.Gui - w *ListWidget - parent *gocui.View + gui *gocui.Gui + widgetList *ListWidget + parent *gocui.View } -func (s *SearchEditor) Edit(v *gocui.View, key gocui.Key, ch rune, mod gocui.Modifier) { - if ch != 0 && mod == 0 { - v.EditWrite(ch) - _ = s.w.searchLine(s.g, s.parent, v.ViewBuffer()) +func (searchEditor *SearchEditor) Edit(view *gocui.View, key gocui.Key, characterAsInteger rune, modifier gocui.Modifier) { + if characterAsInteger != 0 && modifier == 0 { + view.EditWrite(characterAsInteger) + _ = searchEditor.widgetList.searchLine(searchEditor.gui, searchEditor.parent, view.ViewBuffer()) return } switch key { case gocui.KeySpace: - v.EditWrite(' ') - _ = s.w.searchLine(s.g, s.parent, v.ViewBuffer()) + view.EditWrite(' ') + _ = searchEditor.widgetList.searchLine(searchEditor.gui, searchEditor.parent, view.ViewBuffer()) case gocui.KeyBackspace, gocui.KeyBackspace2: - v.EditDelete(true) - _ = s.w.searchLine(s.g, s.parent, v.ViewBuffer()) + view.EditDelete(true) + _ = searchEditor.widgetList.searchLine(searchEditor.gui, searchEditor.parent, view.ViewBuffer()) case gocui.KeyDelete: - v.EditDelete(false) - _ = s.w.searchLine(s.g, s.parent, v.ViewBuffer()) + view.EditDelete(false) + _ = searchEditor.widgetList.searchLine(searchEditor.gui, searchEditor.parent, view.ViewBuffer()) case gocui.KeyInsert: - v.Overwrite = !v.Overwrite + view.Overwrite = !view.Overwrite case gocui.KeyArrowLeft: - v.MoveCursor(-1, 0) + view.MoveCursor(-1, 0) case gocui.KeyArrowRight: - v.MoveCursor(1, 0) + view.MoveCursor(1, 0) case gocui.KeyEsc: // If not here the esc key will act like the KeySpace fallthrough case gocui.KeyEnter: - _ = s.g.DeleteView(v.Name()) + _ = searchEditor.gui.DeleteView(view.Name()) state.modalView = "" - s.g.Cursor = false + searchEditor.gui.Cursor = false default: } } -func (w *ListWidget) prevView(g *gocui.Gui, v *gocui.View) error { - state.curView = w.prev +func (widgetList *ListWidget) prevView(gui *gocui.Gui, view *gocui.View) error { + state.curView = widgetList.prev return nil } -func (w *ListWidget) nextView(g *gocui.Gui, v *gocui.View) error { - state.curView = w.next +func (widgetList *ListWidget) nextView(gui *gocui.Gui, view *gocui.View) error { + state.curView = widgetList.next return nil } -func (w *ListWidget) currentView(g *gocui.Gui, v *gocui.View) error { - state.curView = v.Name() - _, oy := v.Origin() - _, cy := v.Cursor() +func (widgetList *ListWidget) currentView(gui *gocui.Gui, view *gocui.View) error { + state.curView = view.Name() + _, oy := view.Origin() + _, cy := view.Cursor() newSelect := cy + oy - _ = w.selectLine(g, v, newSelect) + _ = widgetList.selectLine(gui, view, newSelect) return nil } -func (w *ListWidget) cursorDown(g *gocui.Gui, v *gocui.View) error { - if v != nil { - _ = w.selectLine(g, v, w.selected+1) +func (widgetList *ListWidget) cursorDown(gui *gocui.Gui, view *gocui.View) error { + if view != nil { + _ = widgetList.selectLine(gui, view, widgetList.selected+1) } return nil } -func (w *ListWidget) cursorUp(g *gocui.Gui, v *gocui.View) error { - if v != nil { - _ = w.selectLine(g, v, w.selected-1) +func (widgetList *ListWidget) cursorUp(gui *gocui.Gui, view *gocui.View) error { + if view != nil { + _ = widgetList.selectLine(gui, view, widgetList.selected-1) } return nil } -func (w *ListWidget) searchLine(g *gocui.Gui, v *gocui.View, s string) error { - if v != nil { - for i, id := range v.ViewBufferLines() { - if strings.Contains(id, s) { - return w.selectLine(g, v, i) +func (widgetList *ListWidget) searchLine(gui *gocui.Gui, view *gocui.View, targetString string) error { + if view != nil { + for line, id := range view.ViewBufferLines() { + if strings.Contains(id, targetString) { + return widgetList.selectLine(gui, view, line) } } } return nil } -func (w *ListWidget) selectLine(g *gocui.Gui, v *gocui.View, selected int) error { - if v != nil { - ox, oy := v.Origin() - _, h := v.Size() +func (widgetList *ListWidget) selectLine(gui *gocui.Gui, view *gocui.View, selected int) error { + if view != nil { + originX, originY := view.Origin() + _, height := view.Size() if selected < 0 { selected = 0 } - if selected >= v.ViewLinesHeight()-1 { - selected = v.ViewLinesHeight() - 2 + if selected >= view.ViewLinesHeight()-1 { + selected = view.ViewLinesHeight() - 2 } // Do nothing if no movement or content is empty - if selected == w.selected || v.ViewLinesHeight() == 0 { + if selected == widgetList.selected || view.ViewLinesHeight() == 0 { return nil } - if w.selected != -1 { - _ = v.SetLine(w.selected, fmt.Sprintf("%s", w.filteredRecords[w.selected])) + if widgetList.selected != -1 { + _ = view.SetLine(widgetList.selected, fmt.Sprintf("%s", widgetList.filteredRecords[widgetList.selected])) } - w.selected = selected - _ = v.SetHighlight(w.selected, true) - - cy := w.selected - oy - if cy < 0 { - oy += cy - cy = 0 - } else if cy >= h { - oy += (cy - h) + 1 - cy -= (cy - h) + 1 + widgetList.selected = selected + _ = view.SetHighlight(widgetList.selected, true) + + cursorPositionY := widgetList.selected - originY + if cursorPositionY < 0 { + originY += cursorPositionY + cursorPositionY = 0 + } else if cursorPositionY >= height { + originY += (cursorPositionY - height) + 1 + cursorPositionY -= (cursorPositionY - height) + 1 } - if err := v.SetOrigin(ox, oy); err != nil { + if err := view.SetOrigin(originX, originY); err != nil { return err } - if err := v.SetCursor(0, cy); err != nil { + if err := view.SetCursor(0, cursorPositionY); err != nil { return err } - if l, err := v.Line(w.selected); err != nil || l == "" { + if line, err := view.Line(widgetList.selected); err != nil || line == "" { return nil } else { - v.Subtitle = fmt.Sprintf("%d/%d", w.selected+1, len(w.filteredRecords)) - if len(w.filteredRecords) > 0 { - w.selectFunc(g, w) + view.Subtitle = fmt.Sprintf("%d/%d", widgetList.selected+1, len(widgetList.filteredRecords)) + if len(widgetList.filteredRecords) > 0 { + widgetList.selectFunc(gui, widgetList) } } } return nil } -func (w *ListWidget) update(g *gocui.Gui, ctx context.Context, finished context.Context) { +func (widgetList *ListWidget) update(gui *gocui.Gui, ctx context.Context, finished context.Context) { time.Sleep(100 * time.Millisecond) - v, err := g.View(w.name) + view, err := gui.View(widgetList.name) if err != nil { panic(err) } - v.Clear() + view.Clear() go func() { defer func() { @@ -324,32 +324,32 @@ func (w *ListWidget) update(g *gocui.Gui, ctx context.Context, finished context. } }() - l := 0 + length := 0 for { select { case <-ctx.Done(): <-finished.Done() return case <-finished.Done(): - if l < len(w.records) { - rec := w.records[l:] - w.upd(g, ctx, rec) + if length < len(widgetList.records) { + rec := widgetList.records[length:] + widgetList.upd(gui, ctx, rec) } return default: - if l < len(w.records) { - rec := w.records[l:] - l = l + len(rec) - w.upd(g, ctx, rec) + if length < len(widgetList.records) { + rec := widgetList.records[length:] + length = length + len(rec) + widgetList.upd(gui, ctx, rec) } } } }() } -func (w *ListWidget) upd(g *gocui.Gui, ctx context.Context, rec []interface{}) { - g.UpdateAsync(func(gui *gocui.Gui) error { - v, err := gui.View(w.name) +func (widgetList *ListWidget) upd(gui *gocui.Gui, ctx context.Context, rec []interface{}) { + gui.UpdateAsync(func(guiInner *gocui.Gui) error { + view, err := guiInner.View(widgetList.name) if err != nil { return err } @@ -359,55 +359,55 @@ func (w *ListWidget) upd(g *gocui.Gui, ctx context.Context, rec []interface{}) { case <-ctx.Done(): return nil default: - if w.filterFunc == nil || w.filterFunc(r) { - w.filteredRecords = append(w.filteredRecords, r) - fmt.Fprintf(v, "%s\n", r) - if len(w.filteredRecords) == 1 { - _ = w.selectLine(g, v, 0) - w.selectFunc(g, w) + if widgetList.filterFunc == nil || widgetList.filterFunc(r) { + widgetList.filteredRecords = append(widgetList.filteredRecords, r) + fmt.Fprintf(view, "%s\n", r) + if len(widgetList.filteredRecords) == 1 { + _ = widgetList.selectLine(gui, view, 0) + widgetList.selectFunc(gui, widgetList) } } } } - v.Subtitle = fmt.Sprintf("%d/%d", w.selected+1, len(w.filteredRecords)) + view.Subtitle = fmt.Sprintf("%d/%d", widgetList.selected+1, len(widgetList.filteredRecords)) return nil }) } -func (w *ListWidget) refreshFilter(g *gocui.Gui, v *gocui.View) error { - if w.cancelRefreshFunc != nil { - w.cancelRefreshFunc() - w.cancelRefreshFunc = nil +func (widgetList *ListWidget) refreshFilter(gui *gocui.Gui, view *gocui.View) error { + if widgetList.cancelRefreshFunc != nil { + widgetList.cancelRefreshFunc() + widgetList.cancelRefreshFunc = nil } // Skip filtering if records is empty and no read operation is in progress - if len(w.records) == 0 && w.finished == nil { + if len(widgetList.records) == 0 && widgetList.finished == nil { return nil } var ctx context.Context - ctx, w.cancelRefreshFunc = context.WithCancel(context.Background()) - v.Clear() - w.filteredRecords = nil - w.selected = -1 + ctx, widgetList.cancelRefreshFunc = context.WithCancel(context.Background()) + view.Clear() + widgetList.filteredRecords = nil + widgetList.selected = -1 go func() { - l := 0 + length := 0 for { select { case <-ctx.Done(): return - case <-w.finished.Done(): - if l < len(w.records) { - rec := w.records[l:] - w.upd(g, ctx, rec) + case <-widgetList.finished.Done(): + if length < len(widgetList.records) { + rec := widgetList.records[length:] + widgetList.upd(gui, ctx, rec) } return default: - if l < len(w.records) { - rec := w.records[l:] - l = l + len(rec) - w.upd(g, ctx, rec) + if length < len(widgetList.records) { + rec := widgetList.records[length:] + length = length + len(rec) + widgetList.upd(gui, ctx, rec) } } } diff --git a/cmd/console/records.go b/cmd/console/records.go index 284a2814..dbadcdb9 100644 --- a/cmd/console/records.go +++ b/cmd/console/records.go @@ -21,88 +21,88 @@ type record struct { hasError bool } -func (r record) String() string { - sb := strings.Builder{} - if r.hasError { - sb.WriteString(escapeFgColor(ErrorColor)) - sb.WriteString(r.id) - sb.WriteString(escapeFgColor(gocui.ColorDefault)) +func (warcRecordRecord record) String() string { + result := strings.Builder{} + if warcRecordRecord.hasError { + result.WriteString(escapeFgColor(ErrorColor)) + result.WriteString(warcRecordRecord.id) + result.WriteString(escapeFgColor(gocui.ColorDefault)) } else { reset := escapeFgColor(gocui.ColorDefault) - switch r.recordType { + switch warcRecordRecord.recordType { case gowarc.Warcinfo: - sb.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(WarcInfoColor), r.id, reset)) + result.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(WarcInfoColor), warcRecordRecord.id, reset)) case gowarc.Request: - sb.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(RequestColor), r.id, reset)) + result.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(RequestColor), warcRecordRecord.id, reset)) case gowarc.Response: - sb.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(ResponseColor), r.id, reset)) + result.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(ResponseColor), warcRecordRecord.id, reset)) case gowarc.Metadata: - sb.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(MetadataColor), r.id, reset)) + result.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(MetadataColor), warcRecordRecord.id, reset)) case gowarc.Resource: - sb.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(ResourceColor), r.id, reset)) + result.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(ResourceColor), warcRecordRecord.id, reset)) case gowarc.Revisit: - sb.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(RevisitColor), r.id, reset)) + result.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(RevisitColor), warcRecordRecord.id, reset)) case gowarc.Continuation: - sb.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(ContinuationColor), r.id, reset)) + result.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(ContinuationColor), warcRecordRecord.id, reset)) case gowarc.Conversion: - sb.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(ConversionColor), r.id, reset)) + result.WriteString(fmt.Sprintf("%s%s%s", escapeFgColor(ConversionColor), warcRecordRecord.id, reset)) default: - sb.WriteString(r.id) + result.WriteString(warcRecordRecord.id) } } - return sb.String() + return result.String() } -func populateRecords(g *gocui.Gui, ctx context.Context, finishedCb func(), widget *ListWidget, data interface{}) { - r, err := gowarc.NewWarcFileReader(data.(string), 0, gowarc.WithBufferTmpDir(viper.GetString(flag.TmpDir))) +func populateRecords(gui *gocui.Gui, ctx context.Context, finishedCb func(), widgetList *ListWidget, data interface{}) { + warcFileReader, err := gowarc.NewWarcFileReader(data.(string), 0, gowarc.WithBufferTmpDir(viper.GetString(flag.TmpDir))) if err != nil { panic(err) } - defer r.Close() + defer warcFileReader.Close() for { select { case <-ctx.Done(): goto end default: - rec, offset, validate, err := r.Next() + warcRecord, offset, validate, err := warcFileReader.Next() if err == io.EOF { goto end } if err != nil { goto end } - _ = rec.ValidateDigest(validate) + _ = warcRecord.ValidateDigest(validate) - wr := record{ - id: rec.WarcHeader().Get(gowarc.WarcRecordID), + warcRecordRecord := record{ + id: warcRecord.WarcHeader().Get(gowarc.WarcRecordID), offset: offset, - recordType: rec.Type(), + recordType: warcRecord.Type(), } - if err := rec.Close(); err != nil { + if err := warcRecord.Close(); err != nil { *validate = append(*validate, err) } - wr.hasError = !validate.Valid() + warcRecordRecord.hasError = !validate.Valid() - widget.records = append(widget.records, wr) + widgetList.records = append(widgetList.records, warcRecordRecord) } } end: finishedCb() } -func populateFiles(g *gocui.Gui, ctx context.Context, finishedCb func(), widget *ListWidget, data interface{}) { +func populateFiles(gui *gocui.Gui, ctx context.Context, finishedCb func(), widgetList *ListWidget, data interface{}) { state.dir = data.(string) - if v, err := g.View("dir"); err == nil { - v.Title = state.dir + if view, err := gui.View("dir"); err == nil { + view.Title = state.dir } if len(state.files) > 0 { - for _, f := range state.files { - for _, suf := range state.suffixes { - if strings.HasSuffix(f, suf) { - widget.records = append(widget.records, f) + for _, file := range state.files { + for _, suffix := range state.suffixes { + if strings.HasSuffix(file, suffix) { + widgetList.records = append(widgetList.records, file) } } } @@ -115,13 +115,13 @@ func populateFiles(g *gocui.Gui, ctx context.Context, finishedCb func(), widget panic(err) } - for _, e := range entries { + for _, entry := range entries { select { case <-ctx.Done(): goto end default: - if strings.HasSuffix(e.Name(), ".warc") || strings.HasSuffix(e.Name(), ".warc.gz") { - widget.records = append(widget.records, e.Name()) + if strings.HasSuffix(entry.Name(), ".warc") || strings.HasSuffix(entry.Name(), ".warc.gz") { + widgetList.records = append(widgetList.records, entry.Name()) } } } @@ -135,27 +135,27 @@ type dirInfo struct { fileInfo fs.FileInfo } -func (di dirInfo) IsDir() bool { - return di.fileInfo.IsDir() +func (directoryInfo dirInfo) IsDir() bool { + return directoryInfo.fileInfo.IsDir() } -func (di dirInfo) Type() fs.FileMode { - return di.fileInfo.Mode().Type() +func (directoryInfo dirInfo) Type() fs.FileMode { + return directoryInfo.fileInfo.Mode().Type() } -func (di dirInfo) Info() (fs.FileInfo, error) { - return di.fileInfo, nil +func (directoryInfo dirInfo) Info() (fs.FileInfo, error) { + return directoryInfo.fileInfo, nil } -func (di dirInfo) Name() string { - return di.fileInfo.Name() +func (directoryInfo dirInfo) Name() string { + return directoryInfo.fileInfo.Name() } // FileInfoToDirEntry returns a DirEntry that returns information from info. // If info is nil, FileInfoToDirEntry returns nil. -func FileInfoToDirEntry(info fs.FileInfo) fs.DirEntry { - if info == nil { +func FileInfoToDirEntry(fileInfo fs.FileInfo) fs.DirEntry { + if fileInfo == nil { return nil } - return dirInfo{fileInfo: info} + return dirInfo{fileInfo: fileInfo} } diff --git a/cmd/console/shortcuthelpwidget.go b/cmd/console/shortcuthelpwidget.go index d0ccc95f..8b0bc13c 100644 --- a/cmd/console/shortcuthelpwidget.go +++ b/cmd/console/shortcuthelpwidget.go @@ -11,28 +11,28 @@ func NewShortcutHelpWidget() *ShortcutHelpWidget { return &ShortcutHelpWidget{} } -func (w *ShortcutHelpWidget) Layout(g *gocui.Gui) error { - maxX, maxY := g.Size() - if v, err := g.SetView(shortcutHelpWidgetName, maxX/2-30, maxY/2-20, maxX/2+30, maxY/2+20, 0); err != nil { +func (shortcutHelpWidget *ShortcutHelpWidget) Layout(gui *gocui.Gui) error { + maxX, maxY := gui.Size() + if view, err := gui.SetView(shortcutHelpWidgetName, maxX/2-30, maxY/2-20, maxX/2+30, maxY/2+20, 0); err != nil { if err != gocui.ErrUnknownView { return err } - v.FgColor = gocui.ColorGreen - v.BgColor = gocui.ColorDefault - v.SelBgColor = gocui.ColorWhite - v.SelFgColor = gocui.ColorBlack - v.Highlight = false - v.Autoscroll = false - v.FrameRunes = []rune{'═', '║', '╔', '╗', '╚', '╝'} - v.Editable = true - v.KeybindOnEdit = false - v.Editor = gocui.EditorFunc(func(v *gocui.View, key gocui.Key, ch rune, mod gocui.Modifier) { + view.FgColor = gocui.ColorGreen + view.BgColor = gocui.ColorDefault + view.SelBgColor = gocui.ColorWhite + view.SelFgColor = gocui.ColorBlack + view.Highlight = false + view.Autoscroll = false + view.FrameRunes = []rune{'═', '║', '╔', '╗', '╚', '╝'} + view.Editable = true + view.KeybindOnEdit = false + view.Editor = gocui.EditorFunc(func(view *gocui.View, key gocui.Key, ch rune, mod gocui.Modifier) { state.modalView = "" - g.Cursor = false - _ = g.DeleteView(shortcutHelpWidgetName) + gui.Cursor = false + _ = gui.DeleteView(shortcutHelpWidgetName) }) - v.Title = shortcutHelpWidgetName - v.WriteString("f: find in current window\n\nFilters:\ne: error\ni: warcinfo\nq: request\nr: response\nm: metadata\nv: revisit\ns: resource\nc: continuation\nn: conversion") + view.Title = shortcutHelpWidgetName + view.WriteString("f: find in current window\n\nFilters:\ne: error\ni: warcinfo\nq: request\nr: response\nm: metadata\nv: revisit\ns: resource\nc: continuation\nn: conversion") } state.modalView = shortcutHelpWidgetName return nil