From cf661e7e154ae188505038e1df8b6cc37f7ac69b Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sat, 13 Apr 2019 10:07:53 -0700 Subject: [PATCH 01/60] WTF-400 Todo extracted to new config format --- cfg/common_settings.go | 50 ++++++++++++++++++++++++++++++++++++++++ main.go | 3 ++- modules/todo/settings.go | 23 ++++++++++++++++++ modules/todo/widget.go | 13 +++++------ wtf/utils.go | 18 +++++++-------- 5 files changed, 90 insertions(+), 17 deletions(-) create mode 100644 cfg/common_settings.go create mode 100644 modules/todo/settings.go diff --git a/cfg/common_settings.go b/cfg/common_settings.go new file mode 100644 index 00000000..ef0d29a2 --- /dev/null +++ b/cfg/common_settings.go @@ -0,0 +1,50 @@ +package cfg + +import ( + "github.com/olebedev/config" +) + +type Colors struct { + Background string + BorderFocusable string + BorderFocused string + BorderNormal string + Checked string + HighlightFore string + HighlightBack string + Text string +} + +type Position struct { + Height int + Left int + Top int + Width int +} + +type Common struct { + Colors + Position + + Enabled bool + RefreshInterval int + Title string +} + +func NewCommonSettingsFromYAML(ymlConfig *config.Config) *Common { + common := Common{ + Colors: Colors{ + Background: ymlConfig.UString("wtf.colors.background", "black"), + BorderFocusable: ymlConfig.UString("wtf.colors.border.focusable"), + BorderFocused: ymlConfig.UString("wtf.colors.border.focused"), + BorderNormal: ymlConfig.UString("wtf.colors.border.normal"), + Checked: ymlConfig.UString("wtf.colors.checked"), + HighlightFore: ymlConfig.UString("wtf.colors.highlight.fore"), + HighlightBack: ymlConfig.UString("wtf.colors.highlight.back"), + Text: ymlConfig.UString("wtf.colors.text", "white"), + }, + Position: Position{}, + } + + return &common +} diff --git a/main.go b/main.go index a9f92bbd..9d37b7e1 100644 --- a/main.go +++ b/main.go @@ -254,7 +254,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w case "textfile": widget = textfile.NewWidget(app, pages) case "todo": - widget = todo.NewWidget(app, pages) + cfg := todo.NewSettingsFromYAML(wtf.Config) + widget = todo.NewWidget(app, pages, cfg) case "todoist": widget = todoist.NewWidget(app, pages) case "travisci": diff --git a/modules/todo/settings.go b/modules/todo/settings.go new file mode 100644 index 00000000..308f5b79 --- /dev/null +++ b/modules/todo/settings.go @@ -0,0 +1,23 @@ +package todo + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + Common *cfg.Common + + FilePath string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.todo") + + settings := Settings{ + Common: cfg.NewCommonSettingsFromYAML(ymlConfig), + FilePath: localConfig.UString("filename"), + } + + return &settings +} diff --git a/modules/todo/widget.go b/modules/todo/widget.go index 5f0abeba..16b30fbd 100644 --- a/modules/todo/widget.go +++ b/modules/todo/widget.go @@ -40,18 +40,20 @@ type Widget struct { wtf.TextWidget app *tview.Application + settings *Settings filePath string list checklist.Checklist pages *tview.Pages } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Todo", "todo", true), app: app, - filePath: wtf.Config.UString("wtf.mods.todo.filename"), + settings: settings, + filePath: settings.FilePath, list: checklist.NewChecklist(), pages: pages, } @@ -255,11 +257,8 @@ func (widget *Widget) modalFocus(form *tview.Form) { } func (widget *Widget) modalForm(lbl, text string) *tview.Form { - form := tview.NewForm(). - SetFieldBackgroundColor(wtf.ColorFor(wtf.Config.UString("wtf.colors.background", "black"))) - - form.SetButtonsAlign(tview.AlignCenter). - SetButtonTextColor(wtf.ColorFor(wtf.Config.UString("wtf.colors.text", "white"))) + form := tview.NewForm().SetFieldBackgroundColor(wtf.ColorFor(widget.settings.Common.Colors.Background)) + form.SetButtonsAlign(tview.AlignCenter).SetButtonTextColor(wtf.ColorFor(widget.settings.Common.Colors.Text)) form.AddInputField(lbl, text, 60, nil, nil) diff --git a/wtf/utils.go b/wtf/utils.go index 234788d6..c8e8ae01 100644 --- a/wtf/utils.go +++ b/wtf/utils.go @@ -96,17 +96,17 @@ func NamesFromEmails(emails []string) []string { // OpenFile opens the file defined in `path` via the operating system func OpenFile(path string) { - if (strings.HasPrefix(path,"http://"))||(strings.HasPrefix(path,"https://")) { + if (strings.HasPrefix(path, "http://")) || (strings.HasPrefix(path, "https://")) { switch runtime.GOOS { - case "linux": - exec.Command("xdg-open", path).Start() - case "windows": - exec.Command("rundll32", "url.dll,FileProtocolHandler", path).Start() - case "darwin": - exec.Command("open", path).Start() - default: + case "linux": + exec.Command("xdg-open", path).Start() + case "windows": + exec.Command("rundll32", "url.dll,FileProtocolHandler", path).Start() + case "darwin": + exec.Command("open", path).Start() + default: } - }else { + } else { filePath, _ := ExpandHomeDir(path) openFileUtil := Config.UString("wtf.openFileUtil", "open") cmd := exec.Command(openFileUtil, filePath) From 936acc0326df8750f5b45ce5594f672427d21621 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sat, 13 Apr 2019 11:36:24 -0700 Subject: [PATCH 02/60] WTF-400 BambooHR extracted to new config format --- main.go | 3 ++- modules/bamboohr/settings.go | 27 +++++++++++++++++++++++++++ modules/bamboohr/widget.go | 23 ++++++++++++----------- 3 files changed, 41 insertions(+), 12 deletions(-) create mode 100644 modules/bamboohr/settings.go diff --git a/main.go b/main.go index 9d37b7e1..e78b430a 100644 --- a/main.go +++ b/main.go @@ -182,7 +182,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w // Always in alphabetical order switch widgetName { case "bamboohr": - widget = bamboohr.NewWidget(app) + cfg := bamboohr.NewSettingsFromYAML(wtf.Config) + widget = bamboohr.NewWidget(app, cfg) case "bargraph": widget = bargraph.NewWidget(app) case "bittrex": diff --git a/modules/bamboohr/settings.go b/modules/bamboohr/settings.go new file mode 100644 index 00000000..223b8c32 --- /dev/null +++ b/modules/bamboohr/settings.go @@ -0,0 +1,27 @@ +package bamboohr + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + Common *cfg.Common + + APIKey string + Subdomain string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.bamboohr") + + settings := Settings{ + Common: cfg.NewCommonSettingsFromYAML(ymlConfig), + APIKey: localConfig.UString("apiKey", os.Getenv("WTF_BAMBOO_HR_TOKEN")), + Subdomain: localConfig.UString("subdomain", os.Getenv("WTF_BAMBOO_HR_SUBDOMAIN")), + } + + return &settings +} diff --git a/modules/bamboohr/widget.go b/modules/bamboohr/widget.go index a757e40a..5fd874c1 100644 --- a/modules/bamboohr/widget.go +++ b/modules/bamboohr/widget.go @@ -2,19 +2,25 @@ package bamboohr import ( "fmt" - "os" + // "os" "github.com/rivo/tview" "github.com/wtfutil/wtf/wtf" ) +const APIURI = "https://api.bamboohr.com/api/gateway.php" + type Widget struct { wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "BambooHR", "bamboohr", false), + + settings: settings, } return &widget @@ -23,17 +29,12 @@ func NewWidget(app *tview.Application) *Widget { /* -------------------- Exported Functions -------------------- */ func (widget *Widget) Refresh() { - apiKey := wtf.Config.UString( - "wtf.mods.bamboohr.apiKey", - os.Getenv("WTF_BAMBOO_HR_TOKEN"), + client := NewClient( + APIURI, + widget.settings.APIKey, + widget.settings.Subdomain, ) - subdomain := wtf.Config.UString( - "wtf.mods.bamboohr.subdomain", - os.Getenv("WTF_BAMBOO_HR_SUBDOMAIN"), - ) - - client := NewClient("https://api.bamboohr.com/api/gateway.php", apiKey, subdomain) todayItems := client.Away( "timeOff", wtf.Now().Format(wtf.DateFormat), From fbf89448af021d02f7c811f48b5a375741d851da Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sat, 13 Apr 2019 11:40:48 -0700 Subject: [PATCH 03/60] WTF-400 CircleCI extracted to new config format --- main.go | 3 ++- modules/circleci/settings.go | 25 +++++++++++++++++++++++++ modules/circleci/widget.go | 17 +++++++---------- 3 files changed, 34 insertions(+), 11 deletions(-) create mode 100644 modules/circleci/settings.go diff --git a/main.go b/main.go index e78b430a..a6e5dd53 100644 --- a/main.go +++ b/main.go @@ -191,7 +191,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w case "blockfolio": widget = blockfolio.NewWidget(app) case "circleci": - widget = circleci.NewWidget(app) + cfg := circleci.NewSettingsFromYAML(wtf.Config) + widget = circleci.NewWidget(app, cfg) case "clocks": widget = clocks.NewWidget(app) case "cmdrunner": diff --git a/modules/circleci/settings.go b/modules/circleci/settings.go new file mode 100644 index 00000000..b9cb9849 --- /dev/null +++ b/modules/circleci/settings.go @@ -0,0 +1,25 @@ +package circleci + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + Common *cfg.Common + + APIKey string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.circleci") + + settings := Settings{ + Common: cfg.NewCommonSettingsFromYAML(ymlConfig), + APIKey: localConfig.UString("apiKey", os.Getenv("WTF_CIRCLE_API_KEY")), + } + + return &settings +} diff --git a/modules/circleci/widget.go b/modules/circleci/widget.go index 7806d074..66b429c2 100644 --- a/modules/circleci/widget.go +++ b/modules/circleci/widget.go @@ -2,7 +2,7 @@ package circleci import ( "fmt" - "os" + // "os" "github.com/rivo/tview" "github.com/wtfutil/wtf/wtf" @@ -11,19 +11,16 @@ import ( type Widget struct { wtf.TextWidget *Client + + settings *Settings } -const apiEnvKey = "WTF_CIRCLE_API_KEY" - -func NewWidget(app *tview.Application) *Widget { - apiKey := wtf.Config.UString( - "wtf.mods.circleci.apiKey", - os.Getenv(apiEnvKey), - ) - +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "CircleCI", "circleci", false), - Client: NewClient(apiKey), + Client: NewClient(settings.APIKey), + + settings: settings, } return &widget From 3db28481691feb0616fe7ff3e83005b673732eda Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sat, 13 Apr 2019 15:43:50 -0700 Subject: [PATCH 04/60] WTF-400 Bittrex extracted to new config format --- main.go | 3 +- modules/cryptoexchanges/bittrex/display.go | 19 ++++++--- modules/cryptoexchanges/bittrex/settings.go | 45 +++++++++++++++++++++ modules/cryptoexchanges/bittrex/widget.go | 34 ++++------------ modules/todo/settings.go | 8 ++-- modules/todo/widget.go | 6 +-- 6 files changed, 75 insertions(+), 40 deletions(-) create mode 100644 modules/cryptoexchanges/bittrex/settings.go diff --git a/main.go b/main.go index a6e5dd53..0fba068c 100644 --- a/main.go +++ b/main.go @@ -187,7 +187,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w case "bargraph": widget = bargraph.NewWidget(app) case "bittrex": - widget = bittrex.NewWidget(app) + cfg := bittrex.NewSettingsFromYAML(wtf.Config) + widget = bittrex.NewWidget(app, cfg) case "blockfolio": widget = blockfolio.NewWidget(app) case "circleci": diff --git a/modules/cryptoexchanges/bittrex/display.go b/modules/cryptoexchanges/bittrex/display.go index 3c8fa6e4..cb8b5001 100644 --- a/modules/cryptoexchanges/bittrex/display.go +++ b/modules/cryptoexchanges/bittrex/display.go @@ -12,14 +12,21 @@ func (widget *Widget) display() { return } - widget.View.SetText(summaryText(&widget.summaryList, &widget.TextColors)) + summaryText := widget.summaryText(&widget.summaryList) + widget.View.SetText(summaryText) } -func summaryText(list *summaryList, colors *TextColors) string { +func (widget *Widget) summaryText(list *summaryList) string { str := "" for _, baseCurrency := range list.items { - str += fmt.Sprintf(" [%s]%s[%s] (%s)\n\n", colors.base.displayName, baseCurrency.displayName, colors.base.name, baseCurrency.name) + str += fmt.Sprintf( + " [%s]%s[%s] (%s)\n\n", + widget.settings.colors.base.displayName, + baseCurrency.displayName, + widget.settings.colors.base.name, + baseCurrency.name, + ) resultTemplate := template.New("bittrex") @@ -38,9 +45,9 @@ func summaryText(list *summaryList, colors *TextColors) string { ) strTemplate.Execute(writer, map[string]string{ - "nameColor": colors.market.name, - "fieldColor": colors.market.field, - "valueColor": colors.market.value, + "nameColor": widget.settings.colors.market.name, + "fieldColor": widget.settings.colors.market.field, + "valueColor": widget.settings.colors.market.value, "mName": marketCurrency.name, "High": marketCurrency.High, "Low": marketCurrency.Low, diff --git a/modules/cryptoexchanges/bittrex/settings.go b/modules/cryptoexchanges/bittrex/settings.go new file mode 100644 index 00000000..6da9111b --- /dev/null +++ b/modules/cryptoexchanges/bittrex/settings.go @@ -0,0 +1,45 @@ +package bittrex + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + base struct { + name string + displayName string + } + market struct { + name string + field string + value string + } +} + +type Settings struct { + colors + common *cfg.Common + + summary map[string]interface{} +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.bittrex") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + settings.colors.base.name = localConfig.UString("colors.base.name") + settings.colors.base.displayName = localConfig.UString("colors.base.displayName") + + settings.colors.market.name = localConfig.UString("colors.market.name") + settings.colors.market.field = localConfig.UString("colors.market.field") + settings.colors.market.value = localConfig.UString("colors.market.value") + + summaryMap, _ := ymlConfig.Map("summary") + settings.summary = summaryMap + + return &settings +} diff --git a/modules/cryptoexchanges/bittrex/widget.go b/modules/cryptoexchanges/bittrex/widget.go index ed11d2d7..532b93f7 100644 --- a/modules/cryptoexchanges/bittrex/widget.go +++ b/modules/cryptoexchanges/bittrex/widget.go @@ -11,56 +11,38 @@ import ( "github.com/wtfutil/wtf/wtf" ) -type TextColors struct { - base struct { - name string - displayName string - } - market struct { - name string - field string - value string - } -} - var ok = true var errorText = "" -var baseURL = "https://bittrex.com/api/v1.1/public/getmarketsummary" +const baseURL = "https://bittrex.com/api/v1.1/public/getmarketsummary" // Widget define wtf widget to register widget later type Widget struct { wtf.TextWidget + + settings *Settings summaryList - TextColors } // NewWidget Make new instance of widget -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Bittrex", "bittrex", false), + TextWidget: wtf.NewTextWidget(app, "Bittrex", "bittrex", false), + + settings: settings, summaryList: summaryList{}, } ok = true errorText = "" - widget.config() widget.setSummaryList() return &widget } -func (widget *Widget) config() { - widget.TextColors.base.name = wtf.Config.UString("wtf.mods.bittrex.colors.base.name", "red") - widget.TextColors.base.displayName = wtf.Config.UString("wtf.mods.bittrex.colors.base.displayName", "grey") - widget.TextColors.market.name = wtf.Config.UString("wtf.mods.bittrex.colors.market.name", "red") - widget.TextColors.market.field = wtf.Config.UString("wtf.mods.bittrex.colors.market.field", "coral") - widget.TextColors.market.value = wtf.Config.UString("wtf.mods.bittrex.colors.market.value", "white") -} - func (widget *Widget) setSummaryList() { - sCurrencies, _ := wtf.Config.Map("wtf.mods.bittrex.summary") + sCurrencies := widget.settings.summary for baseCurrencyName := range sCurrencies { displayName, _ := wtf.Config.String("wtf.mods.bittrex.summary." + baseCurrencyName + ".displayName") mCurrencyList := makeSummaryMarketList(baseCurrencyName) diff --git a/modules/todo/settings.go b/modules/todo/settings.go index 308f5b79..6632ff2b 100644 --- a/modules/todo/settings.go +++ b/modules/todo/settings.go @@ -6,17 +6,17 @@ import ( ) type Settings struct { - Common *cfg.Common + common *cfg.Common - FilePath string + filePath string } func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { localConfig, _ := ymlConfig.Get("wtf.mods.todo") settings := Settings{ - Common: cfg.NewCommonSettingsFromYAML(ymlConfig), - FilePath: localConfig.UString("filename"), + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + filePath: localConfig.UString("filename"), } return &settings diff --git a/modules/todo/widget.go b/modules/todo/widget.go index 16b30fbd..f742b5eb 100644 --- a/modules/todo/widget.go +++ b/modules/todo/widget.go @@ -53,7 +53,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * app: app, settings: settings, - filePath: settings.FilePath, + filePath: settings.filePath, list: checklist.NewChecklist(), pages: pages, } @@ -257,8 +257,8 @@ func (widget *Widget) modalFocus(form *tview.Form) { } func (widget *Widget) modalForm(lbl, text string) *tview.Form { - form := tview.NewForm().SetFieldBackgroundColor(wtf.ColorFor(widget.settings.Common.Colors.Background)) - form.SetButtonsAlign(tview.AlignCenter).SetButtonTextColor(wtf.ColorFor(widget.settings.Common.Colors.Text)) + form := tview.NewForm().SetFieldBackgroundColor(wtf.ColorFor(widget.settings.common.Colors.Background)) + form.SetButtonsAlign(tview.AlignCenter).SetButtonTextColor(wtf.ColorFor(widget.settings.common.Colors.Text)) form.AddInputField(lbl, text, 60, nil, nil) From 1630fb96b748758a140e3952bffda8cc52db2956 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sat, 13 Apr 2019 17:58:32 -0700 Subject: [PATCH 05/60] WTF-400 Blockfolio extracted to new config format --- main.go | 3 +- .../cryptoexchanges/blockfolio/settings.go | 33 +++++++++++ modules/cryptoexchanges/blockfolio/widget.go | 56 +++++++++++++------ 3 files changed, 74 insertions(+), 18 deletions(-) create mode 100644 modules/cryptoexchanges/blockfolio/settings.go diff --git a/main.go b/main.go index 0fba068c..aaa20b17 100644 --- a/main.go +++ b/main.go @@ -190,7 +190,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w cfg := bittrex.NewSettingsFromYAML(wtf.Config) widget = bittrex.NewWidget(app, cfg) case "blockfolio": - widget = blockfolio.NewWidget(app) + cfg := blockfolio.NewSettingsFromYAML(wtf.Config) + widget = blockfolio.NewWidget(app, cfg) case "circleci": cfg := circleci.NewSettingsFromYAML(wtf.Config) widget = circleci.NewWidget(app, cfg) diff --git a/modules/cryptoexchanges/blockfolio/settings.go b/modules/cryptoexchanges/blockfolio/settings.go new file mode 100644 index 00000000..e1f9bb02 --- /dev/null +++ b/modules/cryptoexchanges/blockfolio/settings.go @@ -0,0 +1,33 @@ +package blockfolio + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + name string + grows string + drop string +} + +type Settings struct { + colors + common *cfg.Common + + deviceToken string + displayHoldings bool +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.todo") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + deviceToken: localConfig.UString("device_token"), + displayHoldings: localConfig.UBool("displayHoldings", true), + } + + return &settings +} diff --git a/modules/cryptoexchanges/blockfolio/widget.go b/modules/cryptoexchanges/blockfolio/widget.go index 3c116c88..25dad3cb 100644 --- a/modules/cryptoexchanges/blockfolio/widget.go +++ b/modules/cryptoexchanges/blockfolio/widget.go @@ -15,12 +15,15 @@ type Widget struct { wtf.TextWidget device_token string + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Blockfolio", "blockfolio", false), - device_token: wtf.Config.UString("wtf.mods.blockfolio.device_token"), + TextWidget: wtf.NewTextWidget(app, "Blockfolio", "blockfolio", false), + + device_token: settings.deviceToken, + settings: settings, } return &widget @@ -36,31 +39,50 @@ func (widget *Widget) Refresh() { return } - widget.View.SetText(contentFrom(positions)) + content := widget.contentFrom(positions) + widget.View.SetText(content) } /* -------------------- Unexported Functions -------------------- */ -func contentFrom(positions *AllPositionsResponse) string { +func (widget *Widget) contentFrom(positions *AllPositionsResponse) string { res := "" - colorName := wtf.Config.UString("wtf.mods.blockfolio.colors.name") - colorGrows := wtf.Config.UString("wtf.mods.blockfolio.colors.grows") - colorDrop := wtf.Config.UString("wtf.mods.blockfolio.colors.drop") - displayHoldings := wtf.Config.UBool("wtf.mods.blockfolio.displayHoldings") - var totalFiat float32 - totalFiat = 0.0 + totalFiat := float32(0.0) + for i := 0; i < len(positions.PositionList); i++ { - colorForChange := colorGrows + colorForChange := widget.settings.colors.grows + if positions.PositionList[i].TwentyFourHourPercentChangeFiat <= 0 { - colorForChange = colorDrop + colorForChange = widget.settings.colors.drop } + totalFiat += positions.PositionList[i].HoldingValueFiat - if displayHoldings { - res = res + fmt.Sprintf("[%s]%-6s - %5.2f ([%s]%.3fk [%s]%.2f%s)\n", colorName, positions.PositionList[i].Coin, positions.PositionList[i].Quantity, colorForChange, positions.PositionList[i].HoldingValueFiat/1000, colorForChange, positions.PositionList[i].TwentyFourHourPercentChangeFiat, "%") + + if widget.settings.displayHoldings { + res = res + fmt.Sprintf( + "[%s]%-6s - %5.2f ([%s]%.3fk [%s]%.2f%s)\n", + widget.settings.colors.name, + positions.PositionList[i].Coin, + positions.PositionList[i].Quantity, + colorForChange, + positions.PositionList[i].HoldingValueFiat/1000, + colorForChange, + positions.PositionList[i].TwentyFourHourPercentChangeFiat, + "%", + ) } else { - res = res + fmt.Sprintf("[%s]%-6s - %5.2f ([%s]%.2f%s)\n", colorName, positions.PositionList[i].Coin, positions.PositionList[i].Quantity, colorForChange, positions.PositionList[i].TwentyFourHourPercentChangeFiat, "%") + res = res + fmt.Sprintf( + "[%s]%-6s - %5.2f ([%s]%.2f%s)\n", + widget.settings.colors.name, + positions.PositionList[i].Coin, + positions.PositionList[i].Quantity, + colorForChange, + positions.PositionList[i].TwentyFourHourPercentChangeFiat, + "%", + ) } } - if displayHoldings { + + if widget.settings.displayHoldings { res = res + fmt.Sprintf("\n[%s]Total value: $%.3fk", "green", totalFiat/1000) } From 37356679ccbe6cbd399154d34da94b26fce701cf Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sat, 13 Apr 2019 18:46:46 -0700 Subject: [PATCH 06/60] WTF-400 Clocks extracted to new config format --- main.go | 3 ++- modules/clocks/display.go | 10 +++++++--- modules/clocks/setting.go | 42 +++++++++++++++++++++++++++++++++++++++ modules/clocks/widget.go | 12 ++++++----- 4 files changed, 58 insertions(+), 9 deletions(-) create mode 100644 modules/clocks/setting.go diff --git a/main.go b/main.go index aaa20b17..5e603178 100644 --- a/main.go +++ b/main.go @@ -196,7 +196,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w cfg := circleci.NewSettingsFromYAML(wtf.Config) widget = circleci.NewWidget(app, cfg) case "clocks": - widget = clocks.NewWidget(app) + cfg := clocks.NewSettingsFromYAML(wtf.Config) + widget = clocks.NewWidget(app, cfg) case "cmdrunner": widget = cmdrunner.NewWidget(app) case "cryptolive": diff --git a/modules/clocks/display.go b/modules/clocks/display.go index 0516e197..9448aa06 100644 --- a/modules/clocks/display.go +++ b/modules/clocks/display.go @@ -2,8 +2,6 @@ package clocks import ( "fmt" - - "github.com/wtfutil/wtf/wtf" ) func (widget *Widget) display(clocks []Clock, dateFormat string, timeFormat string) { @@ -14,9 +12,15 @@ func (widget *Widget) display(clocks []Clock, dateFormat string, timeFormat stri str := "" for idx, clock := range clocks { + rowColor := widget.settings.colors.rows.odd + + if idx%2 == 0 { + rowColor = widget.settings.colors.rows.even + } + str = str + fmt.Sprintf( " [%s]%-12s %-10s %7s[white]\n", - wtf.RowColor("clocks", idx), + rowColor, clock.Label, clock.Time(timeFormat), clock.Date(dateFormat), diff --git a/modules/clocks/setting.go b/modules/clocks/setting.go new file mode 100644 index 00000000..3fbc856a --- /dev/null +++ b/modules/clocks/setting.go @@ -0,0 +1,42 @@ +package clocks + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" + "github.com/wtfutil/wtf/wtf" +) + +type colors struct { + rows struct { + even string + odd string + } +} + +type Settings struct { + colors + common *cfg.Common + + dateFormat string + timeFormat string + locations map[string]interface{} + sort string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.clocks") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + dateFormat: localConfig.UString("dateFormat", wtf.SimpleDateFormat), + timeFormat: localConfig.UString("timeFormat", wtf.SimpleTimeFormat), + locations: localConfig.UMap("locations"), + sort: localConfig.UString("sort"), + } + + settings.colors.rows.even = localConfig.UString("colors.rows.even", "white") + settings.colors.rows.odd = localConfig.UString("colors.rows.odd", "blue") + + return &settings +} diff --git a/modules/clocks/widget.go b/modules/clocks/widget.go index 38d19ac0..11cfc18d 100644 --- a/modules/clocks/widget.go +++ b/modules/clocks/widget.go @@ -14,17 +14,19 @@ type Widget struct { clockColl ClockCollection dateFormat string timeFormat string + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "World Clocks", "clocks", false), + + settings: settings, + dateFormat: settings.dateFormat, + timeFormat: settings.timeFormat, } - widget.clockColl = widget.buildClockCollection(wtf.Config.UMap("wtf.mods.clocks.locations")) - - widget.dateFormat = wtf.Config.UString("wtf.mods.clocks.dateFormat", wtf.SimpleDateFormat) - widget.timeFormat = wtf.Config.UString("wtf.mods.clocks.timeFormat", wtf.SimpleTimeFormat) + widget.clockColl = widget.buildClockCollection(settings.locations) return &widget } From 73e0e18ebc259df62cffe352c8b7a61f3fdd7dd5 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sat, 13 Apr 2019 18:59:39 -0700 Subject: [PATCH 07/60] WTF-400 CmdRunner extracted to new config format --- main.go | 3 ++- modules/bamboohr/widget.go | 1 - modules/circleci/widget.go | 1 - modules/cmdrunner/settings.go | 27 +++++++++++++++++++++++++++ modules/cmdrunner/widget.go | 14 ++++++++------ 5 files changed, 37 insertions(+), 9 deletions(-) create mode 100644 modules/cmdrunner/settings.go diff --git a/main.go b/main.go index 5e603178..a10fafdb 100644 --- a/main.go +++ b/main.go @@ -199,7 +199,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w cfg := clocks.NewSettingsFromYAML(wtf.Config) widget = clocks.NewWidget(app, cfg) case "cmdrunner": - widget = cmdrunner.NewWidget(app) + cfg := cmdrunner.NewSettingsFromYAML(wtf.Config) + widget = cmdrunner.NewWidget(app, cfg) case "cryptolive": widget = cryptolive.NewWidget(app) case "datadog": diff --git a/modules/bamboohr/widget.go b/modules/bamboohr/widget.go index 5fd874c1..5091cecb 100644 --- a/modules/bamboohr/widget.go +++ b/modules/bamboohr/widget.go @@ -2,7 +2,6 @@ package bamboohr import ( "fmt" - // "os" "github.com/rivo/tview" "github.com/wtfutil/wtf/wtf" diff --git a/modules/circleci/widget.go b/modules/circleci/widget.go index 66b429c2..ce8ecf62 100644 --- a/modules/circleci/widget.go +++ b/modules/circleci/widget.go @@ -2,7 +2,6 @@ package circleci import ( "fmt" - // "os" "github.com/rivo/tview" "github.com/wtfutil/wtf/wtf" diff --git a/modules/cmdrunner/settings.go b/modules/cmdrunner/settings.go new file mode 100644 index 00000000..1629e25f --- /dev/null +++ b/modules/cmdrunner/settings.go @@ -0,0 +1,27 @@ +package cmdrunner + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" + "github.com/wtfutil/wtf/wtf" +) + +type Settings struct { + common *cfg.Common + + args []string + cmd string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.cmdrunner") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + args: wtf.ToStrs(wtf.Config.UList("args")), + cmd: localConfig.UString("cmd"), + } + + return &settings +} diff --git a/modules/cmdrunner/widget.go b/modules/cmdrunner/widget.go index 2c812db9..5d1fd13c 100644 --- a/modules/cmdrunner/widget.go +++ b/modules/cmdrunner/widget.go @@ -12,17 +12,19 @@ import ( type Widget struct { wtf.TextWidget - args []string - cmd string - result string + args []string + cmd string + result string + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "CmdRunner", "cmdrunner", false), - args: wtf.ToStrs(wtf.Config.UList("wtf.mods.cmdrunner.args")), - cmd: wtf.Config.UString("wtf.mods.cmdrunner.cmd"), + args: settings.args, + cmd: settings.cmd, + settings: settings, } widget.View.SetWrap(true) From 27b4274d3846249188ee991d5c7a98beff04f53f Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 10:04:58 -0700 Subject: [PATCH 08/60] WTF-400 Cryptolive extracted to new config format --- main.go | 3 +- .../cryptolive/price/settings.go | 63 ++++++++++++++++ .../cryptolive/price/widget.go | 34 +++++---- .../cryptoexchanges/cryptolive/settings.go | 71 +++++++++++++++++++ .../cryptolive/toplist/display.go | 33 +++++---- .../cryptolive/toplist/settings.go | 63 ++++++++++++++++ .../cryptolive/toplist/widget.go | 37 ++-------- modules/cryptoexchanges/cryptolive/widget.go | 12 ++-- 8 files changed, 254 insertions(+), 62 deletions(-) create mode 100644 modules/cryptoexchanges/cryptolive/price/settings.go create mode 100644 modules/cryptoexchanges/cryptolive/settings.go create mode 100644 modules/cryptoexchanges/cryptolive/toplist/settings.go diff --git a/main.go b/main.go index a10fafdb..ffa92f0d 100644 --- a/main.go +++ b/main.go @@ -202,7 +202,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w cfg := cmdrunner.NewSettingsFromYAML(wtf.Config) widget = cmdrunner.NewWidget(app, cfg) case "cryptolive": - widget = cryptolive.NewWidget(app) + cfg := cryptolive.NewSettingsFromYAML(wtf.Config) + widget = cryptolive.NewWidget(app, cfg) case "datadog": widget = datadog.NewWidget(app) case "gcal": diff --git a/modules/cryptoexchanges/cryptolive/price/settings.go b/modules/cryptoexchanges/cryptolive/price/settings.go new file mode 100644 index 00000000..2dd5cbef --- /dev/null +++ b/modules/cryptoexchanges/cryptolive/price/settings.go @@ -0,0 +1,63 @@ +package price + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + from struct { + name string + displayName string + } + to struct { + name string + price string + } + top struct { + from struct { + name string + displayName string + } + to struct { + name string + field string + value string + } + } +} + +type Settings struct { + colors + common *cfg.Common + currencies map[string]interface{} + top map[string]interface{} +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.cryptolive") + + currencies, _ := localConfig.Map("currencies") + top, _ := localConfig.Map("top") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + currencies: currencies, + top: top, + } + + settings.colors.from.name = localConfig.UString("colors.from.name") + settings.colors.from.displayName = localConfig.UString("colors.from.displayName") + + settings.colors.to.name = localConfig.UString("colors.to.name") + settings.colors.to.price = localConfig.UString("colors.to.price") + + settings.colors.top.from.name = localConfig.UString("colors.top.from.name") + settings.colors.top.from.displayName = localConfig.UString("colors.top.from.displayName") + + settings.colors.top.to.name = localConfig.UString("colors.top.to.name") + settings.colors.top.to.field = localConfig.UString("colors.top.to.field") + settings.colors.top.to.value = localConfig.UString("colors.top.to.value") + + return &settings +} diff --git a/modules/cryptoexchanges/cryptolive/price/widget.go b/modules/cryptoexchanges/cryptolive/price/widget.go index 4984f70e..42fc5ae9 100644 --- a/modules/cryptoexchanges/cryptolive/price/widget.go +++ b/modules/cryptoexchanges/cryptolive/price/widget.go @@ -16,6 +16,7 @@ var ok = true // Widget define wtf widget to register widget later type Widget struct { *list + settings *Settings Result string @@ -23,8 +24,10 @@ type Widget struct { } // NewWidget Make new instance of widget -func NewWidget() *Widget { - widget := Widget{} +func NewWidget(settings *Settings) *Widget { + widget := Widget{ + settings: settings, + } widget.setList() @@ -32,11 +35,9 @@ func NewWidget() *Widget { } func (widget *Widget) setList() { - currenciesMap, _ := wtf.Config.Map("wtf.mods.cryptolive.currencies") - widget.list = &list{} - for currency := range currenciesMap { + for currency := range widget.settings.currencies { displayName, _ := wtf.Config.String("wtf.mods.cryptolive.currencies." + currency + ".displayName") toList := getToList(currency) widget.list.addItem(currency, displayName, toList) @@ -66,16 +67,23 @@ func (widget *Widget) Refresh(wg *sync.WaitGroup) { func (widget *Widget) display() { str := "" - var ( - fromNameColor = wtf.Config.UString("wtf.mods.cryptolive.colors.from.name", "coral") - fromDisplayNameColor = wtf.Config.UString("wtf.mods.cryptolive.colors.from.displayName", "grey") - toNameColor = wtf.Config.UString("wtf.mods.cryptolive.colors.to.name", "white") - toPriceColor = wtf.Config.UString("wtf.mods.cryptolive.colors.to.price", "green") - ) + for _, item := range widget.list.items { - str += fmt.Sprintf(" [%s]%s[%s] (%s)\n", fromNameColor, item.displayName, fromDisplayNameColor, item.name) + str += fmt.Sprintf( + " [%s]%s[%s] (%s)\n", + widget.settings.colors.from.name, + item.displayName, + widget.settings.colors.from.name, + item.name, + ) for _, toItem := range item.to { - str += fmt.Sprintf("\t[%s]%s: [%s]%f\n", toNameColor, toItem.name, toPriceColor, toItem.price) + str += fmt.Sprintf( + "\t[%s]%s: [%s]%f\n", + widget.settings.colors.to.name, + toItem.name, + widget.settings.colors.to.price, + toItem.price, + ) } str += "\n" } diff --git a/modules/cryptoexchanges/cryptolive/settings.go b/modules/cryptoexchanges/cryptolive/settings.go new file mode 100644 index 00000000..abffae4d --- /dev/null +++ b/modules/cryptoexchanges/cryptolive/settings.go @@ -0,0 +1,71 @@ +package cryptolive + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" + "github.com/wtfutil/wtf/modules/cryptoexchanges/cryptolive/price" + "github.com/wtfutil/wtf/modules/cryptoexchanges/cryptolive/toplist" +) + +type colors struct { + from struct { + name string + displayName string + } + to struct { + name string + price string + } + top struct { + from struct { + name string + displayName string + } + to struct { + name string + field string + value string + } + } +} + +type Settings struct { + colors + common *cfg.Common + currencies map[string]interface{} + top map[string]interface{} + + priceSettings *price.Settings + toplistSettings *toplist.Settings +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.cryptolive") + + currencies, _ := localConfig.Map("currencies") + top, _ := localConfig.Map("top") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + currencies: currencies, + top: top, + + priceSettings: price.NewSettingsFromYAML(ymlConfig), + toplistSettings: toplist.NewSettingsFromYAML(ymlConfig), + } + + settings.colors.from.name = localConfig.UString("colors.from.name") + settings.colors.from.displayName = localConfig.UString("colors.from.displayName") + + settings.colors.to.name = localConfig.UString("colors.to.name") + settings.colors.to.price = localConfig.UString("colors.to.price") + + settings.colors.top.from.name = localConfig.UString("colors.top.from.name") + settings.colors.top.from.displayName = localConfig.UString("colors.top.from.displayName") + + settings.colors.top.to.name = localConfig.UString("colors.top.to.name") + settings.colors.top.to.field = localConfig.UString("colors.top.to.field") + settings.colors.top.to.value = localConfig.UString("colors.top.to.value") + + return &settings +} diff --git a/modules/cryptoexchanges/cryptolive/toplist/display.go b/modules/cryptoexchanges/cryptolive/toplist/display.go index 53d6da16..f8950b95 100644 --- a/modules/cryptoexchanges/cryptolive/toplist/display.go +++ b/modules/cryptoexchanges/cryptolive/toplist/display.go @@ -7,49 +7,54 @@ func (widget *Widget) display() { for _, fromCurrency := range widget.list.items { str += fmt.Sprintf( "[%s]%s [%s](%s)\n", - widget.colors.from.displayName, + widget.settings.colors.from.displayName, fromCurrency.displayName, - widget.colors.from.name, + widget.settings.colors.from.name, fromCurrency.name, ) - str += makeToListText(fromCurrency.to, widget.colors) + str += widget.makeToListText(fromCurrency.to) } widget.Result = str } -func makeToListText(toList []*tCurrency, colors textColors) string { +func (widget *Widget) makeToListText(toList []*tCurrency) string { str := "" for _, toCurrency := range toList { - str += makeToText(toCurrency, colors) + str += widget.makeToText(toCurrency) } return str } -func makeToText(toCurrency *tCurrency, colors textColors) string { +func (widget *Widget) makeToText(toCurrency *tCurrency) string { str := "" - str += fmt.Sprintf(" [%s]%s\n", colors.to.name, toCurrency.name) + str += fmt.Sprintf( + " [%s]%s\n", + widget.settings.colors.to.name, + toCurrency.name, + ) + for _, info := range toCurrency.info { - str += makeInfoText(info, colors) + str += widget.makeInfoText(info) str += "\n\n" } return str } -func makeInfoText(info tInfo, colors textColors) string { +func (widget *Widget) makeInfoText(info tInfo) string { return fmt.Sprintf( " [%s]Exchange: [%s]%s\n", - colors.to.field, - colors.to.value, + widget.settings.colors.top.to.field, + widget.settings.colors.top.to.value, info.exchange, ) + fmt.Sprintf( " [%s]Volume(24h): [%s]%f-[%s]%f", - colors.to.field, - colors.to.value, + widget.settings.colors.top.to.field, + widget.settings.colors.top.to.value, info.volume24h, - colors.to.value, + widget.settings.colors.top.to.value, info.volume24hTo, ) } diff --git a/modules/cryptoexchanges/cryptolive/toplist/settings.go b/modules/cryptoexchanges/cryptolive/toplist/settings.go new file mode 100644 index 00000000..d7844192 --- /dev/null +++ b/modules/cryptoexchanges/cryptolive/toplist/settings.go @@ -0,0 +1,63 @@ +package toplist + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + from struct { + name string + displayName string + } + to struct { + name string + price string + } + top struct { + from struct { + name string + displayName string + } + to struct { + name string + field string + value string + } + } +} + +type Settings struct { + colors + common *cfg.Common + currencies map[string]interface{} + top map[string]interface{} +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.cryptolive") + + currencies, _ := localConfig.Map("currencies") + top, _ := localConfig.Map("top") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + currencies: currencies, + top: top, + } + + settings.colors.from.name = localConfig.UString("colors.from.name") + settings.colors.from.displayName = localConfig.UString("colors.from.displayName") + + settings.colors.to.name = localConfig.UString("colors.to.name") + settings.colors.to.price = localConfig.UString("colors.to.price") + + settings.colors.top.from.name = localConfig.UString("colors.top.from.name") + settings.colors.top.from.displayName = localConfig.UString("colors.top.from.displayName") + + settings.colors.top.to.name = localConfig.UString("colors.top.to.name") + settings.colors.top.to.field = localConfig.UString("colors.top.to.field") + settings.colors.top.to.value = localConfig.UString("colors.top.to.value") + + return &settings +} diff --git a/modules/cryptoexchanges/cryptolive/toplist/widget.go b/modules/cryptoexchanges/cryptolive/toplist/widget.go index 5c433fec..b06a3b24 100644 --- a/modules/cryptoexchanges/cryptolive/toplist/widget.go +++ b/modules/cryptoexchanges/cryptolive/toplist/widget.go @@ -13,44 +13,30 @@ import ( var baseURL = "https://min-api.cryptocompare.com/data/top/exchanges" -type textColors struct { - from struct { - name string - displayName string - } - to struct { - name string - field string - value string - } -} - // Widget Toplist Widget type Widget struct { Result string RefreshInterval int - list *cList - - colors textColors + list *cList + settings *Settings } // NewWidget Make new toplist widget -func NewWidget() *Widget { - widget := Widget{} +func NewWidget(settings *Settings) *Widget { + widget := Widget{ + settings: settings, + } widget.list = &cList{} widget.setList() - widget.config() return &widget } func (widget *Widget) setList() { - currenciesMap, _ := wtf.Config.Map("wtf.mods.cryptolive.top") - - for fromCurrency := range currenciesMap { + for fromCurrency := range widget.settings.top { displayName := wtf.Config.UString("wtf.mods.cryptolive.top."+fromCurrency+".displayName", "") limit := wtf.Config.UInt("wtf.mods.cryptolive.top."+fromCurrency+".limit", 1) widget.list.addItem(fromCurrency, displayName, limit, makeToList(fromCurrency, limit)) @@ -70,15 +56,6 @@ func makeToList(fCurrencyName string, limit int) (list []*tCurrency) { return } -func (widget *Widget) config() { - // set colors - widget.colors.from.name = wtf.Config.UString("wtf.mods.cryptolive.colors.top.from.name", "coral") - widget.colors.from.displayName = wtf.Config.UString("wtf.mods.cryptolive.colors.top.from.displayName", "grey") - widget.colors.to.name = wtf.Config.UString("wtf.mods.cryptolive.colors.top.to.name", "red") - widget.colors.to.field = wtf.Config.UString("wtf.mods.cryptolive.colors.top.to.field", "white") - widget.colors.to.value = wtf.Config.UString("wtf.mods.cryptolive.colors.top.to.value", "value") -} - /* -------------------- Exported Functions -------------------- */ // Refresh & update after interval time diff --git a/modules/cryptoexchanges/cryptolive/widget.go b/modules/cryptoexchanges/cryptolive/widget.go index 1671bfb2..199e1bf2 100644 --- a/modules/cryptoexchanges/cryptolive/widget.go +++ b/modules/cryptoexchanges/cryptolive/widget.go @@ -13,16 +13,20 @@ import ( // Widget define wtf widget to register widget later type Widget struct { wtf.TextWidget + priceWidget *price.Widget toplistWidget *toplist.Widget + settings *Settings } // NewWidget Make new instance of widget -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "CryptoLive", "cryptolive", false), - priceWidget: price.NewWidget(), - toplistWidget: toplist.NewWidget(), + TextWidget: wtf.NewTextWidget(app, "CryptoLive", "cryptolive", false), + + priceWidget: price.NewWidget(settings.priceSettings), + toplistWidget: toplist.NewWidget(settings.toplistSettings), + settings: settings, } widget.priceWidget.RefreshInterval = widget.RefreshInterval() From 5e1fdef5d4d1a2af94e56e65b8fe5d268015b0c7 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 11:27:50 -0700 Subject: [PATCH 09/60] WTF-400 DataDog extracted to new config format --- main.go | 3 ++- modules/datadog/client.go | 27 ++++++++------------------- modules/datadog/settings.go | 29 +++++++++++++++++++++++++++++ modules/datadog/widget.go | 8 ++++++-- 4 files changed, 45 insertions(+), 22 deletions(-) create mode 100644 modules/datadog/settings.go diff --git a/main.go b/main.go index ffa92f0d..d6829638 100644 --- a/main.go +++ b/main.go @@ -205,7 +205,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w cfg := cryptolive.NewSettingsFromYAML(wtf.Config) widget = cryptolive.NewWidget(app, cfg) case "datadog": - widget = datadog.NewWidget(app) + cfg := datadog.NewSettingsFromYAML(wtf.Config) + widget = datadog.NewWidget(app, cfg) case "gcal": widget = gcal.NewWidget(app) case "gerrit": diff --git a/modules/datadog/client.go b/modules/datadog/client.go index d9d4e238..ce9a2406 100644 --- a/modules/datadog/client.go +++ b/modules/datadog/client.go @@ -1,34 +1,23 @@ package datadog import ( - "os" - "github.com/wtfutil/wtf/wtf" datadog "github.com/zorkian/go-datadog-api" ) // Monitors returns a list of newrelic monitors -func Monitors() ([]datadog.Monitor, error) { - client := datadog.NewClient(apiKey(), applicationKey()) +func (widget *Widget) Monitors() ([]datadog.Monitor, error) { + client := datadog.NewClient( + widget.settings.apiKey, + widget.settings.applicationKey, + ) - monitors, err := client.GetMonitorsByTags(wtf.ToStrs(wtf.Config.UList("wtf.mods.datadog.monitors.tags"))) + tags := wtf.ToStrs(widget.settings.tags) + + monitors, err := client.GetMonitorsByTags(tags) if err != nil { return nil, err } return monitors, nil } - -func apiKey() string { - return wtf.Config.UString( - "wtf.mods.datadog.apiKey", - os.Getenv("WTF_DATADOG_API_KEY"), - ) -} - -func applicationKey() string { - return wtf.Config.UString( - "wtf.mods.datadog.applicationKey", - os.Getenv("WTF_DATADOG_APPLICATION_KEY"), - ) -} diff --git a/modules/datadog/settings.go b/modules/datadog/settings.go new file mode 100644 index 00000000..a74c1b85 --- /dev/null +++ b/modules/datadog/settings.go @@ -0,0 +1,29 @@ +package datadog + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiKey string + applicationKey string + tags []interface{} +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.todo") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_DATADOG_API_KEY")), + applicationKey: localConfig.UString("applicationKey", os.Getenv("WTF_DATADOG_APPLICATION_KEY")), + tags: localConfig.UList("monitors.tags"), + } + + return &settings +} diff --git a/modules/datadog/widget.go b/modules/datadog/widget.go index 5ed2f9b9..71bb1212 100644 --- a/modules/datadog/widget.go +++ b/modules/datadog/widget.go @@ -10,11 +10,15 @@ import ( type Widget struct { wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "Datadog", "datadog", false), + + settings: settings, } return &widget @@ -23,7 +27,7 @@ func NewWidget(app *tview.Application) *Widget { /* -------------------- Exported Functions -------------------- */ func (widget *Widget) Refresh() { - monitors, monitorErr := Monitors() + monitors, monitorErr := widget.Monitors() widget.View.SetTitle(widget.ContextualTitle(fmt.Sprintf("%s", widget.Name()))) widget.View.Clear() From 12a895b9df85ca12aa428570049eed58f6405741 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 12:36:38 -0700 Subject: [PATCH 10/60] WTF-400 GCal extracted to new config format --- main.go | 3 ++- modules/gcal/client.go | 19 +++++++------- modules/gcal/display.go | 30 ++++++++++----------- modules/gcal/settings.go | 57 ++++++++++++++++++++++++++++++++++++++++ modules/gcal/widget.go | 20 +++++++------- 5 files changed, 94 insertions(+), 35 deletions(-) create mode 100644 modules/gcal/settings.go diff --git a/main.go b/main.go index d6829638..030d31c8 100644 --- a/main.go +++ b/main.go @@ -208,7 +208,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w cfg := datadog.NewSettingsFromYAML(wtf.Config) widget = datadog.NewWidget(app, cfg) case "gcal": - widget = gcal.NewWidget(app) + cfg := gcal.NewSettingsFromYAML(wtf.Config) + widget = gcal.NewWidget(app, cfg) case "gerrit": widget = gerrit.NewWidget(app, pages) case "git": diff --git a/modules/gcal/client.go b/modules/gcal/client.go index 06f6ccd1..ee475af5 100644 --- a/modules/gcal/client.go +++ b/modules/gcal/client.go @@ -27,10 +27,10 @@ import ( /* -------------------- Exported Functions -------------------- */ -func Fetch() ([]*CalEvent, error) { +func (widget *Widget) Fetch() ([]*CalEvent, error) { ctx := context.Background() - secretPath, _ := wtf.ExpandHomeDir(wtf.Config.UString("wtf.mods.gcal.secretFile")) + secretPath, _ := wtf.ExpandHomeDir(widget.settings.secretFile) b, err := ioutil.ReadFile(secretPath) if err != nil { @@ -48,13 +48,13 @@ func Fetch() ([]*CalEvent, error) { return nil, err } - calendarIds, err := getCalendarIdList(srv) + calendarIds, err := widget.getCalendarIdList(srv) // Get calendar events var events calendar.Events startTime := fromMidnight().Format(time.RFC3339) - eventLimit := int64(wtf.Config.UInt("wtf.mods.gcal.eventCount", 10)) + eventLimit := int64(widget.settings.eventCount) for _, calendarId := range calendarIds { calendarEvents, err := srv.Events.List(calendarId).ShowDeleted(false).TimeMin(startTime).MaxResults(eventLimit).SingleEvents(true).OrderBy("startTime").Do() @@ -122,13 +122,12 @@ func isAuthenticated() bool { return err == nil } -func authenticate() { - filename := wtf.Config.UString("wtf.mods.gcal.secretFile") - secretPath, _ := wtf.ExpandHomeDir(filename) +func (widget *Widget) authenticate() { + secretPath, _ := wtf.ExpandHomeDir(widget.settings.secretFile) b, err := ioutil.ReadFile(secretPath) if err != nil { - log.Fatalf("Unable to read secret file. %v", filename) + log.Fatalf("Unable to read secret file. %v", widget.settings.secretFile) } config, err := google.ConfigFromJSON(b, calendar.CalendarReadonlyScope) @@ -188,9 +187,9 @@ func saveToken(file string, token *oauth2.Token) { json.NewEncoder(f).Encode(token) } -func getCalendarIdList(srv *calendar.Service) ([]string, error) { +func (widget *Widget) getCalendarIdList(srv *calendar.Service) ([]string, error) { // Return single calendar if settings specify we should - if !wtf.Config.UBool("wtf.mods.gcal.multiCalendar", false) { + if !widget.settings.multiCalendar { id, err := srv.CalendarList.Get("primary").Do() if err != nil { return nil, err diff --git a/modules/gcal/display.go b/modules/gcal/display.go index af2b34c2..09fcbafb 100644 --- a/modules/gcal/display.go +++ b/modules/gcal/display.go @@ -44,8 +44,8 @@ func (widget *Widget) contentFrom(calEvents []*CalEvent) string { var str string var prevEvent *CalEvent - if !wtf.Config.UBool("wtf.mods.gcal.showDeclined", false) { - calEvents = removeDeclined(calEvents) + if !widget.settings.showDeclined { + calEvents = widget.removeDeclined(calEvents) } for _, calEvent := range calEvents { @@ -101,7 +101,7 @@ func (widget *Widget) dayDivider(event, prevEvent *CalEvent) string { if !eventStartDay.Equal(prevStartDay) { return fmt.Sprintf("[%s::b]", - wtf.Config.UString("wtf.mods.gcal.colors.day", "forestgreen")) + + widget.settings.colors.day) + event.Start().Format(wtf.FullDateFormat) + "\n" } @@ -111,10 +111,10 @@ func (widget *Widget) dayDivider(event, prevEvent *CalEvent) string { func (widget *Widget) descriptionColor(calEvent *CalEvent) string { if calEvent.Past() { - return wtf.Config.UString("wtf.mods.gcal.colors.past", "gray") + return widget.settings.colors.past } - return wtf.Config.UString("wtf.mods.gcal.colors.description", "white") + return widget.settings.colors.description } func (widget *Widget) eventSummary(calEvent *CalEvent, conflict bool) string { @@ -123,13 +123,13 @@ func (widget *Widget) eventSummary(calEvent *CalEvent, conflict bool) string { if calEvent.Now() { summary = fmt.Sprintf( "%s %s", - wtf.Config.UString("wtf.mods.gcal.currentIcon", "🔸"), + widget.settings.currentIcon, summary, ) } if conflict { - return fmt.Sprintf("%s %s", wtf.Config.UString("wtf.mods.gcal.conflictIcon", "🚨"), summary) + return fmt.Sprintf("%s %s", widget.settings.conflictIcon, summary) } return summary @@ -170,9 +170,9 @@ func (widget *Widget) timeUntil(calEvent *CalEvent) string { } func (widget *Widget) titleColor(calEvent *CalEvent) string { - color := wtf.Config.UString("wtf.mods.gcal.colors.title", "white") + color := widget.settings.colors.title - for _, untypedArr := range wtf.Config.UList("wtf.mods.gcal.colors.highlights") { + for _, untypedArr := range widget.settings.highlights { highlightElements := wtf.ToStrs(untypedArr.([]interface{})) match, _ := regexp.MatchString( @@ -186,14 +186,14 @@ func (widget *Widget) titleColor(calEvent *CalEvent) string { } if calEvent.Past() { - color = wtf.Config.UString("wtf.mods.gcal.colors.past", "gray") + color = widget.settings.colors.past } return color } func (widget *Widget) location(calEvent *CalEvent) string { - if wtf.Config.UBool("wtf.mods.gcal.displayLocation", true) == false { + if widget.settings.withLocation == false { return "" } @@ -209,13 +209,13 @@ func (widget *Widget) location(calEvent *CalEvent) string { } func (widget *Widget) responseIcon(calEvent *CalEvent) string { - if false == wtf.Config.UBool("wtf.mods.gcal.displayResponseStatus", true) { + if widget.settings.displayResponseStatus == false { return "" } icon := "[gray]" - switch calEvent.ResponseFor(wtf.Config.UString("wtf.mods.gcal.email")) { + switch calEvent.ResponseFor(widget.settings.email) { case "accepted": return icon + "✔︎" case "declined": @@ -229,10 +229,10 @@ func (widget *Widget) responseIcon(calEvent *CalEvent) string { } } -func removeDeclined(events []*CalEvent) []*CalEvent { +func (widget *Widget) removeDeclined(events []*CalEvent) []*CalEvent { var ret []*CalEvent for _, e := range events { - if e.ResponseFor(wtf.Config.UString("wtf.mods.gcal.email")) != "declined" { + if e.ResponseFor(widget.settings.email) != "declined" { ret = append(ret, e) } } diff --git a/modules/gcal/settings.go b/modules/gcal/settings.go new file mode 100644 index 00000000..861b1c68 --- /dev/null +++ b/modules/gcal/settings.go @@ -0,0 +1,57 @@ +package gcal + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + day string + description string + past string + title string + + highlights []interface{} +} + +type Settings struct { + colors + common *cfg.Common + + conflictIcon string + currentIcon string + displayResponseStatus bool + email string + eventCount int + multiCalendar bool + secretFile string + showDeclined bool + textInterval int + withLocation bool +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.gcal") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + conflictIcon: localConfig.UString("conflictIcon", "🚨"), + currentIcon: localConfig.UString("currentIcon", "🔸"), + displayResponseStatus: localConfig.UBool("displayResponseStatus", true), + email: localConfig.UString("email", ""), + eventCount: localConfig.UInt("eventCount", 10), + multiCalendar: localConfig.UBool("multiCalendar", false), + secretFile: localConfig.UString("secretFile", ""), + showDeclined: localConfig.UBool("showDeclined", false), + textInterval: localConfig.UInt("textInterval", 30), + withLocation: localConfig.UBool("withLocation", true), + } + + settings.colors.day = localConfig.UString("colors.day", "forestgreen") + settings.colors.description = localConfig.UString("colors.description", "white") + settings.colors.past = localConfig.UString("colors.past", "gray") + settings.colors.title = localConfig.UString("colors.title", "white") + + return &settings +} diff --git a/modules/gcal/widget.go b/modules/gcal/widget.go index 5095a0d8..53a68501 100644 --- a/modules/gcal/widget.go +++ b/modules/gcal/widget.go @@ -11,17 +11,20 @@ import ( type Widget struct { wtf.TextWidget + app *tview.Application calEvents []*CalEvent ch chan struct{} mutex sync.Mutex - app *tview.Application + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "Calendar", "gcal", true), - ch: make(chan struct{}), - app: app, + + app: app, + ch: make(chan struct{}), + settings: settings, } go updateLoop(&widget) @@ -41,14 +44,14 @@ func (widget *Widget) Refresh() { widget.fetchAndDisplayEvents() return } - widget.app.Suspend(authenticate) + widget.app.Suspend(widget.authenticate) widget.Refresh() } /* -------------------- Unexported Functions -------------------- */ func (widget *Widget) fetchAndDisplayEvents() { - calEvents, err := Fetch() + calEvents, err := widget.Fetch() if err != nil { widget.calEvents = []*CalEvent{} } else { @@ -58,12 +61,11 @@ func (widget *Widget) fetchAndDisplayEvents() { } func updateLoop(widget *Widget) { - interval := wtf.Config.UInt("wtf.mods.gcal.textInterval", 30) - if interval == 0 { + if widget.settings.textInterval == 0 { return } - tick := time.NewTicker(time.Duration(interval) * time.Second) + tick := time.NewTicker(time.Duration(widget.settings.textInterval) * time.Second) defer tick.Stop() outer: for { From fcbfd8e9a769c1ddec8bb12636deacd3532db0f6 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 13:24:03 -0700 Subject: [PATCH 11/60] WTF-400 Gerrit extracted to new config format --- main.go | 3 ++- modules/gerrit/display.go | 4 +-- modules/gerrit/gerrit_repo.go | 4 +-- modules/gerrit/settings.go | 45 ++++++++++++++++++++++++++++++++++ modules/gerrit/widget.go | 46 +++++++++++++++++------------------ 5 files changed, 72 insertions(+), 30 deletions(-) create mode 100644 modules/gerrit/settings.go diff --git a/main.go b/main.go index 030d31c8..14f73445 100644 --- a/main.go +++ b/main.go @@ -211,7 +211,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w cfg := gcal.NewSettingsFromYAML(wtf.Config) widget = gcal.NewWidget(app, cfg) case "gerrit": - widget = gerrit.NewWidget(app, pages) + cfg := gerrit.NewSettingsFromYAML(wtf.Config) + widget = gerrit.NewWidget(app, pages, cfg) case "git": widget = git.NewWidget(app, pages) case "github": diff --git a/modules/gerrit/display.go b/modules/gerrit/display.go index 770c3231..fc320013 100644 --- a/modules/gerrit/display.go +++ b/modules/gerrit/display.go @@ -21,10 +21,10 @@ func (widget *Widget) display() { str = str + widget.displayStats(project) str = str + "\n" str = str + " [red]Open Incoming Reviews[white]\n" - str = str + widget.displayMyIncomingReviews(project, wtf.Config.UString("wtf.mods.gerrit.username")) + str = str + widget.displayMyIncomingReviews(project, widget.settings.username) str = str + "\n" str = str + " [red]My Outgoing Reviews[white]\n" - str = str + widget.displayMyOutgoingReviews(project, wtf.Config.UString("wtf.mods.gerrit.username")) + str = str + widget.displayMyOutgoingReviews(project, widget.settings.username) widget.View.SetText(str) } diff --git a/modules/gerrit/gerrit_repo.go b/modules/gerrit/gerrit_repo.go index dbe58889..b171da1f 100644 --- a/modules/gerrit/gerrit_repo.go +++ b/modules/gerrit/gerrit_repo.go @@ -2,7 +2,6 @@ package gerrit import ( glb "github.com/andygrunwald/go-gerrit" - "github.com/wtfutil/wtf/wtf" ) type GerritProject struct { @@ -25,8 +24,7 @@ func NewGerritProject(path string, gerrit *glb.Client) *GerritProject { } // Refresh reloads the gerrit data via the Gerrit API -func (project *GerritProject) Refresh() { - username := wtf.Config.UString("wtf.mods.gerrit.username") +func (project *GerritProject) Refresh(username string) { project.Changes, _ = project.loadChanges() project.ReviewCount = project.countReviews(project.Changes) diff --git a/modules/gerrit/settings.go b/modules/gerrit/settings.go new file mode 100644 index 00000000..91c9f423 --- /dev/null +++ b/modules/gerrit/settings.go @@ -0,0 +1,45 @@ +package gerrit + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + rows struct { + even string + odd string + } +} + +type Settings struct { + colors + common *cfg.Common + + domain string + password string + projects []interface{} + username string + verifyServerCertificate bool +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.gerrit") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + domain: localConfig.UString("domain", ""), + password: localConfig.UString("password", os.Getenv("WTF_GERRIT_PASSWORD")), + projects: localConfig.UList("projects"), + username: localConfig.UString("username", ""), + verifyServerCertificate: localConfig.UBool("verifyServerCertificate", true), + } + + settings.colors.rows.even = localConfig.UString("colors.rows.even", "white") + settings.colors.rows.odd = localConfig.UString("colors.rows.odd", "blue") + + return &settings +} diff --git a/modules/gerrit/widget.go b/modules/gerrit/widget.go index 6fcdaee9..f7185aaf 100644 --- a/modules/gerrit/widget.go +++ b/modules/gerrit/widget.go @@ -4,7 +4,7 @@ import ( "crypto/tls" "fmt" "net/http" - "os" + // "os" "regexp" glb "github.com/andygrunwald/go-gerrit" @@ -40,18 +40,20 @@ type Widget struct { GerritProjects []*GerritProject Idx int selected int + settings *Settings } var ( GerritURLPattern = regexp.MustCompile(`^(http|https)://(.*)$`) ) -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Gerrit", "gerrit", true), - Idx: 0, + Idx: 0, + settings: settings, } widget.HelpfulWidget.SetView(widget.View) @@ -65,31 +67,27 @@ func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { /* -------------------- Exported Functions -------------------- */ func (widget *Widget) Refresh() { - baseURL := wtf.Config.UString("wtf.mods.gerrit.domain") - username := wtf.Config.UString("wtf.mods.gerrit.username") - - password := wtf.Config.UString( - "wtf.mods.gerrit.password", - os.Getenv("WTF_GERRIT_PASSWORD"), - ) - - verifyServerCertificate := wtf.Config.UBool("wtf.mods.gerrit.verifyServerCertificate", true) - - httpClient := &http.Client{Transport: &http.Transport{ - TLSClientConfig: &tls.Config{ - InsecureSkipVerify: !verifyServerCertificate, + httpClient := &http.Client{ + Transport: &http.Transport{ + TLSClientConfig: &tls.Config{ + InsecureSkipVerify: !widget.settings.verifyServerCertificate, + }, + Proxy: http.ProxyFromEnvironment, }, - Proxy: http.ProxyFromEnvironment, - }, } - gerritUrl := baseURL - submatches := GerritURLPattern.FindAllStringSubmatch(baseURL, -1) + gerritUrl := widget.settings.domain + submatches := GerritURLPattern.FindAllStringSubmatch(widget.settings.domain, -1) if len(submatches) > 0 && len(submatches[0]) > 2 { submatch := submatches[0] gerritUrl = fmt.Sprintf( - "%s://%s:%s@%s", submatch[1], username, password, submatch[2]) + "%s://%s:%s@%s", + submatch[1], + widget.settings.username, + widget.settings.password, + submatch[2], + ) } gerrit, err := glb.NewClient(gerritUrl, httpClient) if err != nil { @@ -99,10 +97,10 @@ func (widget *Widget) Refresh() { return } widget.gerrit = gerrit - widget.GerritProjects = widget.buildProjectCollection(wtf.Config.UList("wtf.mods.gerrit.projects")) + widget.GerritProjects = widget.buildProjectCollection(widget.settings.projects) for _, project := range widget.GerritProjects { - project.Refresh() + project.Refresh(widget.settings.username) } widget.display() @@ -159,7 +157,7 @@ func (widget *Widget) openReview() { } else { change = project.OutgoingReviews[sel-len(project.IncomingReviews)] } - wtf.OpenFile(fmt.Sprintf("%s/%s/%d", wtf.Config.UString("wtf.mods.gerrit.domain"), "#/c", change.Number)) + wtf.OpenFile(fmt.Sprintf("%s/%s/%d", widget.settings.domain, "#/c", change.Number)) } } From 0790493c53c9f04291b9e09de7057a341413f7c3 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 13:33:48 -0700 Subject: [PATCH 12/60] WTF-400 Fix wrong YAML identifier for some modules --- modules/cryptoexchanges/blockfolio/settings.go | 2 +- modules/datadog/settings.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/cryptoexchanges/blockfolio/settings.go b/modules/cryptoexchanges/blockfolio/settings.go index e1f9bb02..0ccb1320 100644 --- a/modules/cryptoexchanges/blockfolio/settings.go +++ b/modules/cryptoexchanges/blockfolio/settings.go @@ -20,7 +20,7 @@ type Settings struct { } func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.todo") + localConfig, _ := ymlConfig.Get("wtf.mods.blockfolio") settings := Settings{ common: cfg.NewCommonSettingsFromYAML(ymlConfig), diff --git a/modules/datadog/settings.go b/modules/datadog/settings.go index a74c1b85..d448402a 100644 --- a/modules/datadog/settings.go +++ b/modules/datadog/settings.go @@ -16,7 +16,7 @@ type Settings struct { } func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.todo") + localConfig, _ := ymlConfig.Get("wtf.mods.datadog") settings := Settings{ common: cfg.NewCommonSettingsFromYAML(ymlConfig), From 095041be61c50477befa108759465fdd06cdd088 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 16:15:10 -0700 Subject: [PATCH 13/60] WTF-400 Git extracted to new config format --- main.go | 3 ++- modules/git/git_repo.go | 12 ++++-------- modules/git/settings.go | 30 ++++++++++++++++++++++++++++++ modules/git/widget.go | 37 +++++++++++++++++++++++++++---------- 4 files changed, 63 insertions(+), 19 deletions(-) create mode 100644 modules/git/settings.go diff --git a/main.go b/main.go index 14f73445..7433cd6c 100644 --- a/main.go +++ b/main.go @@ -214,7 +214,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w cfg := gerrit.NewSettingsFromYAML(wtf.Config) widget = gerrit.NewWidget(app, pages, cfg) case "git": - widget = git.NewWidget(app, pages) + cfg := git.NewSettingsFromYAML(wtf.Config) + widget = git.NewWidget(app, pages, cfg) case "github": widget = github.NewWidget(app, pages) case "gitlab": diff --git a/modules/git/git_repo.go b/modules/git/git_repo.go index a402d988..b53e6ed4 100644 --- a/modules/git/git_repo.go +++ b/modules/git/git_repo.go @@ -16,12 +16,12 @@ type GitRepo struct { Path string } -func NewGitRepo(repoPath string) *GitRepo { +func NewGitRepo(repoPath string, commitCount int, commitFormat, dateFormat string) *GitRepo { repo := GitRepo{Path: repoPath} repo.Branch = repo.branch() repo.ChangedFiles = repo.changedFiles() - repo.Commits = repo.commits() + repo.Commits = repo.commits(commitCount, commitFormat, dateFormat) repo.Repository = strings.TrimSpace(repo.repository()) return &repo @@ -49,13 +49,9 @@ func (repo *GitRepo) changedFiles() []string { return data } -func (repo *GitRepo) commits() []string { - numStr := fmt.Sprintf("-n %d", wtf.Config.UInt("wtf.mods.git.commitCount", 10)) - - dateFormat := wtf.Config.UString("wtf.mods.git.dateFormat", "%b %d, %Y") +func (repo *GitRepo) commits(commitCount int, commitFormat, dateFormat string) []string { dateStr := fmt.Sprintf("--date=format:\"%s\"", dateFormat) - - commitFormat := wtf.Config.UString("wtf.mods.git.commitFormat", "[forestgreen]%h [white]%s [grey]%an on %cd[white]") + numStr := fmt.Sprintf("-n %d", commitCount) commitStr := fmt.Sprintf("--pretty=format:\"%s\"", commitFormat) arg := []string{repo.gitDir(), repo.workTree(), "log", dateStr, numStr, commitStr} diff --git a/modules/git/settings.go b/modules/git/settings.go new file mode 100644 index 00000000..d54a69a9 --- /dev/null +++ b/modules/git/settings.go @@ -0,0 +1,30 @@ +package git + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + commitCount int + commitFormat string + dateFormat string + repositories []interface{} +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.git") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + commitCount: localConfig.UInt("commitCount", 10), + commitFormat: localConfig.UString("commitFormat", "[forestgreen]%h [white]%s [grey]%an on %cd[white]"), + dateFormat: localConfig.UString("dateFormat", "%b %d, %Y"), + repositories: localConfig.UList("repositories"), + } + + return &settings +} diff --git a/modules/git/widget.go b/modules/git/widget.go index b94550e1..9231ff55 100644 --- a/modules/git/widget.go +++ b/modules/git/widget.go @@ -32,19 +32,22 @@ type Widget struct { wtf.MultiSourceWidget wtf.TextWidget - app *tview.Application GitRepos []*GitRepo + + app *tview.Application pages *tview.Pages + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), MultiSourceWidget: wtf.NewMultiSourceWidget("git", "repository", "repositories"), TextWidget: wtf.NewTextWidget(app, "Git", "git", true), - app: app, - pages: pages, + app: app, + pages: pages, + settings: settings, } widget.LoadSources() @@ -83,7 +86,7 @@ func (widget *Widget) Pull() { } func (widget *Widget) Refresh() { - repoPaths := wtf.ToStrs(wtf.Config.UList("wtf.mods.git.repositories")) + repoPaths := wtf.ToStrs(widget.settings.repositories) widget.GitRepos = widget.gitRepos(repoPaths) sort.Slice(widget.GitRepos, func(i, j int) bool { @@ -164,10 +167,16 @@ func (widget *Widget) gitRepos(repoPaths []string) []*GitRepo { for _, repoPath := range repoPaths { if strings.HasSuffix(repoPath, "/") { - repos = append(repos, findGitRepositories(make([]*GitRepo, 0), repoPath)...) + repos = append(repos, widget.findGitRepositories(make([]*GitRepo, 0), repoPath)...) } else { - repo := NewGitRepo(repoPath) + repo := NewGitRepo( + repoPath, + widget.settings.commitCount, + widget.settings.commitFormat, + widget.settings.dateFormat, + ) + repos = append(repos, repo) } } @@ -175,7 +184,7 @@ func (widget *Widget) gitRepos(repoPaths []string) []*GitRepo { return repos } -func findGitRepositories(repositories []*GitRepo, directory string) []*GitRepo { +func (widget *Widget) findGitRepositories(repositories []*GitRepo, directory string) []*GitRepo { directory = strings.TrimSuffix(directory, "/") files, err := ioutil.ReadDir(directory) @@ -188,16 +197,24 @@ func findGitRepositories(repositories []*GitRepo, directory string) []*GitRepo { for _, file := range files { if file.IsDir() { path = directory + "/" + file.Name() + if file.Name() == ".git" { path = strings.TrimSuffix(path, "/.git") - repo := NewGitRepo(path) + + repo := NewGitRepo( + path, + widget.settings.commitCount, + widget.settings.commitFormat, + widget.settings.dateFormat, + ) + repositories = append(repositories, repo) continue } if file.Name() == "vendor" || file.Name() == "node_modules" { continue } - repositories = findGitRepositories(repositories, path) + repositories = widget.findGitRepositories(repositories, path) } } From 6c22ad6d2782eb22c0a33658fe9c7c4861794faf Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 16:29:13 -0700 Subject: [PATCH 14/60] WTF-400 GitHub extracted to new config format --- main.go | 47 ++++++++++++++++++----------------- modules/github/display.go | 16 +++++------- modules/github/github_repo.go | 30 ++++++---------------- modules/github/settings.go | 36 +++++++++++++++++++++++++++ modules/github/widget.go | 17 ++++++++++--- 5 files changed, 86 insertions(+), 60 deletions(-) create mode 100644 modules/github/settings.go diff --git a/main.go b/main.go index 7433cd6c..d7088082 100644 --- a/main.go +++ b/main.go @@ -182,42 +182,43 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w // Always in alphabetical order switch widgetName { case "bamboohr": - cfg := bamboohr.NewSettingsFromYAML(wtf.Config) - widget = bamboohr.NewWidget(app, cfg) + settings := bamboohr.NewSettingsFromYAML(wtf.Config) + widget = bamboohr.NewWidget(app, settings) case "bargraph": widget = bargraph.NewWidget(app) case "bittrex": - cfg := bittrex.NewSettingsFromYAML(wtf.Config) - widget = bittrex.NewWidget(app, cfg) + settings := bittrex.NewSettingsFromYAML(wtf.Config) + widget = bittrex.NewWidget(app, settings) case "blockfolio": - cfg := blockfolio.NewSettingsFromYAML(wtf.Config) - widget = blockfolio.NewWidget(app, cfg) + settings := blockfolio.NewSettingsFromYAML(wtf.Config) + widget = blockfolio.NewWidget(app, settings) case "circleci": - cfg := circleci.NewSettingsFromYAML(wtf.Config) - widget = circleci.NewWidget(app, cfg) + settings := circleci.NewSettingsFromYAML(wtf.Config) + widget = circleci.NewWidget(app, settings) case "clocks": - cfg := clocks.NewSettingsFromYAML(wtf.Config) - widget = clocks.NewWidget(app, cfg) + settings := clocks.NewSettingsFromYAML(wtf.Config) + widget = clocks.NewWidget(app, settings) case "cmdrunner": - cfg := cmdrunner.NewSettingsFromYAML(wtf.Config) - widget = cmdrunner.NewWidget(app, cfg) + settings := cmdrunner.NewSettingsFromYAML(wtf.Config) + widget = cmdrunner.NewWidget(app, settings) case "cryptolive": - cfg := cryptolive.NewSettingsFromYAML(wtf.Config) - widget = cryptolive.NewWidget(app, cfg) + settings := cryptolive.NewSettingsFromYAML(wtf.Config) + widget = cryptolive.NewWidget(app, settings) case "datadog": - cfg := datadog.NewSettingsFromYAML(wtf.Config) - widget = datadog.NewWidget(app, cfg) + settings := datadog.NewSettingsFromYAML(wtf.Config) + widget = datadog.NewWidget(app, settings) case "gcal": - cfg := gcal.NewSettingsFromYAML(wtf.Config) - widget = gcal.NewWidget(app, cfg) + settings := gcal.NewSettingsFromYAML(wtf.Config) + widget = gcal.NewWidget(app, settings) case "gerrit": - cfg := gerrit.NewSettingsFromYAML(wtf.Config) - widget = gerrit.NewWidget(app, pages, cfg) + settings := gerrit.NewSettingsFromYAML(wtf.Config) + widget = gerrit.NewWidget(app, pages, settings) case "git": - cfg := git.NewSettingsFromYAML(wtf.Config) - widget = git.NewWidget(app, pages, cfg) + settings := git.NewSettingsFromYAML(wtf.Config) + widget = git.NewWidget(app, pages, settings) case "github": - widget = github.NewWidget(app, pages) + settings := github.NewSettingsFromYAML(wtf.Config) + widget = github.NewWidget(app, pages, settings) case "gitlab": widget = gitlab.NewWidget(app, pages) case "gitter": diff --git a/modules/github/display.go b/modules/github/display.go index 556f38a3..1819efa2 100644 --- a/modules/github/display.go +++ b/modules/github/display.go @@ -21,16 +21,16 @@ func (widget *Widget) display() { str = str + widget.displayStats(repo) str = str + "\n" str = str + " [red]Open Review Requests[white]\n" - str = str + widget.displayMyReviewRequests(repo, wtf.Config.UString("wtf.mods.github.username")) + str = str + widget.displayMyReviewRequests(repo, widget.settings.username) str = str + "\n" str = str + " [red]My Pull Requests[white]\n" - str = str + widget.displayMyPullRequests(repo, wtf.Config.UString("wtf.mods.github.username")) + str = str + widget.displayMyPullRequests(repo, widget.settings.username) widget.View.SetText(str) } func (widget *Widget) displayMyPullRequests(repo *GithubRepo, username string) string { - prs := repo.myPullRequests(username) + prs := repo.myPullRequests(username, widget.settings.enableStatus) if len(prs) == 0 { return " [grey]none[white]\n" @@ -38,7 +38,7 @@ func (widget *Widget) displayMyPullRequests(repo *GithubRepo, username string) s str := "" for _, pr := range prs { - str = str + fmt.Sprintf(" %s[green]%4d[white] %s\n", mergeString(pr), *pr.Number, *pr.Title) + str = str + fmt.Sprintf(" %s[green]%4d[white] %s\n", widget.mergeString(pr), *pr.Number, *pr.Title) } return str @@ -74,10 +74,6 @@ func (widget *Widget) title(repo *GithubRepo) string { return fmt.Sprintf("[green]%s - %s[white]", repo.Owner, repo.Name) } -func showStatus() bool { - return wtf.Config.UBool("wtf.mods.github.enableStatus", false) -} - var mergeIcons = map[string]string{ "dirty": "[red]![white] ", "clean": "[green]✔[white] ", @@ -85,8 +81,8 @@ var mergeIcons = map[string]string{ "blocked": "[red]✖[white] ", } -func mergeString(pr *github.PullRequest) string { - if !showStatus() { +func (widget *Widget) mergeString(pr *github.PullRequest) string { + if !widget.settings.enableStatus { return "" } if str, ok := mergeIcons[pr.GetMergeableState()]; ok { diff --git a/modules/github/github_repo.go b/modules/github/github_repo.go index 1860de61..65636795 100644 --- a/modules/github/github_repo.go +++ b/modules/github/github_repo.go @@ -3,7 +3,6 @@ package github import ( "context" "net/http" - "os" ghb "github.com/google/go-github/github" "github.com/wtfutil/wtf/wtf" @@ -21,13 +20,15 @@ type GithubRepo struct { RemoteRepo *ghb.Repository } -func NewGithubRepo(name, owner string) *GithubRepo { +func NewGithubRepo(name, owner, apiKey, baseURL, uploadURL string) *GithubRepo { repo := GithubRepo{ Name: name, Owner: owner, - } - repo.loadAPICredentials() + apiKey: apiKey, + baseURL: baseURL, + uploadURL: uploadURL, + } return &repo } @@ -94,25 +95,8 @@ func (repo *GithubRepo) githubClient() (*ghb.Client, error) { return ghb.NewClient(oauthClient), nil } -func (repo *GithubRepo) loadAPICredentials() { - repo.apiKey = wtf.Config.UString( - "wtf.mods.github.apiKey", - os.Getenv("WTF_GITHUB_TOKEN"), - ) - - repo.baseURL = wtf.Config.UString( - "wtf.mods.github.baseURL", - os.Getenv("WTF_GITHUB_BASE_URL"), - ) - - repo.uploadURL = wtf.Config.UString( - "wtf.mods.github.uploadURL", - os.Getenv("WTF_GITHUB_UPLOAD_URL"), - ) -} - // myPullRequests returns a list of pull requests created by username on this repo -func (repo *GithubRepo) myPullRequests(username string) []*ghb.PullRequest { +func (repo *GithubRepo) myPullRequests(username string, showStatus bool) []*ghb.PullRequest { prs := []*ghb.PullRequest{} for _, pr := range repo.PullRequests { @@ -123,7 +107,7 @@ func (repo *GithubRepo) myPullRequests(username string) []*ghb.PullRequest { } } - if showStatus() { + if showStatus { prs = repo.individualPRs(prs) } diff --git a/modules/github/settings.go b/modules/github/settings.go new file mode 100644 index 00000000..14fd0ee1 --- /dev/null +++ b/modules/github/settings.go @@ -0,0 +1,36 @@ +package github + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiKey string + baseURL string + enableStatus bool + repositories map[string]interface{} + uploadURL string + username string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.github") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_GITHUB_TOKEN")), + baseURL: localConfig.UString("baseURL", os.Getenv("WTF_GITHUB_BASE_URL")), + enableStatus: localConfig.UBool("enableStatus", false), + repositories: localConfig.UMap("repositories"), + uploadURL: localConfig.UString("uploadURL", os.Getenv("WTF_GITHUB_UPLOAD_URL")), + username: localConfig.UString("username"), + } + + return &settings +} diff --git a/modules/github/widget.go b/modules/github/widget.go index 2bafc598..69e4f136 100644 --- a/modules/github/widget.go +++ b/modules/github/widget.go @@ -26,17 +26,19 @@ type Widget struct { GithubRepos []*GithubRepo Idx int + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "GitHub", "github", true), - Idx: 0, + Idx: 0, + settings: settings, } - widget.GithubRepos = widget.buildRepoCollection(wtf.Config.UMap("wtf.mods.github.repositories")) + widget.GithubRepos = widget.buildRepoCollection(widget.settings.repositories) widget.HelpfulWidget.SetView(widget.View) widget.View.SetInputCapture(widget.keyboardIntercept) @@ -78,7 +80,14 @@ func (widget *Widget) buildRepoCollection(repoData map[string]interface{}) []*Gi githubRepos := []*GithubRepo{} for name, owner := range repoData { - repo := NewGithubRepo(name, owner.(string)) + repo := NewGithubRepo( + name, + owner.(string), + widget.settings.apiKey, + widget.settings.baseURL, + widget.settings.uploadURL, + ) + githubRepos = append(githubRepos, repo) } From 50726b4f07e623641f3e2bfa157ffff3f4429a47 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 19:39:04 -0700 Subject: [PATCH 15/60] WTF-400 GitLab extracted to new config format --- main.go | 3 ++- modules/gitlab/display.go | 4 ++-- modules/gitlab/settings.go | 32 ++++++++++++++++++++++++++++++++ modules/gitlab/widget.go | 27 +++++++++------------------ 4 files changed, 45 insertions(+), 21 deletions(-) create mode 100644 modules/gitlab/settings.go diff --git a/main.go b/main.go index d7088082..6c3ea1fe 100644 --- a/main.go +++ b/main.go @@ -220,7 +220,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := github.NewSettingsFromYAML(wtf.Config) widget = github.NewWidget(app, pages, settings) case "gitlab": - widget = gitlab.NewWidget(app, pages) + settings := gitlab.NewSettingsFromYAML(wtf.Config) + widget = gitlab.NewWidget(app, pages, settings) case "gitter": widget = gitter.NewWidget(app, pages) case "gspreadsheets": diff --git a/modules/gitlab/display.go b/modules/gitlab/display.go index 3899d7f2..51cdfcc9 100644 --- a/modules/gitlab/display.go +++ b/modules/gitlab/display.go @@ -21,10 +21,10 @@ func (widget *Widget) display() { str = str + widget.displayStats(project) str = str + "\n" str = str + " [red]Open Approval Requests[white]\n" - str = str + widget.displayMyApprovalRequests(project, wtf.Config.UString("wtf.mods.gitlab.username")) + str = str + widget.displayMyApprovalRequests(project, widget.settings.username) str = str + "\n" str = str + " [red]My Merge Requests[white]\n" - str = str + widget.displayMyMergeRequests(project, wtf.Config.UString("wtf.mods.gitlab.username")) + str = str + widget.displayMyMergeRequests(project, widget.settings.username) widget.View.SetText(str) } diff --git a/modules/gitlab/settings.go b/modules/gitlab/settings.go new file mode 100644 index 00000000..51ca388a --- /dev/null +++ b/modules/gitlab/settings.go @@ -0,0 +1,32 @@ +package gitlab + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiKey string + domain string + projects map[string]interface{} + username string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.gitlab") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_GITLAB_TOKEN")), + domain: localConfig.UString("domain"), + projects: localConfig.UMap("projects"), + username: localConfig.UString("username"), + } + + return &settings +} diff --git a/modules/gitlab/widget.go b/modules/gitlab/widget.go index 8001e84f..a0d3f00f 100644 --- a/modules/gitlab/widget.go +++ b/modules/gitlab/widget.go @@ -1,8 +1,6 @@ package gitlab import ( - "os" - "github.com/gdamore/tcell" "github.com/rivo/tview" "github.com/wtfutil/wtf/wtf" @@ -25,15 +23,15 @@ type Widget struct { wtf.HelpfulWidget wtf.TextWidget - gitlab *glb.Client - GitlabProjects []*GitlabProject Idx int + gitlab *glb.Client + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { - baseURL := wtf.Config.UString("wtf.mods.gitlab.domain") - gitlab := glb.NewClient(nil, apiKey()) +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { + baseURL := settings.domain + gitlab := glb.NewClient(nil, settings.apiKey) if baseURL != "" { gitlab.SetBaseURL(baseURL) @@ -43,12 +41,12 @@ func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Gitlab", "gitlab", true), - gitlab: gitlab, - - Idx: 0, + Idx: 0, + gitlab: gitlab, + settings: settings, } - widget.GitlabProjects = widget.buildProjectCollection(wtf.Config.UMap("wtf.mods.gitlab.projects")) + widget.GitlabProjects = widget.buildProjectCollection(settings.projects) widget.HelpfulWidget.SetView(widget.View) widget.View.SetInputCapture(widget.keyboardIntercept) @@ -86,13 +84,6 @@ func (widget *Widget) Prev() { /* -------------------- Unexported Functions -------------------- */ -func apiKey() string { - return wtf.Config.UString( - "wtf.mods.gitlab.apiKey", - os.Getenv("WTF_GITLAB_TOKEN"), - ) -} - func (widget *Widget) buildProjectCollection(projectData map[string]interface{}) []*GitlabProject { gitlabProjects := []*GitlabProject{} From 6e053fc117e3633deab3393f8aa81d388f1baa4a Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 19:45:27 -0700 Subject: [PATCH 16/60] WTF-400 Gitter extracted to new config format --- main.go | 3 ++- modules/gitter/client.go | 21 ++++++--------------- modules/gitter/settings.go | 30 ++++++++++++++++++++++++++++++ modules/gitter/widget.go | 11 +++++++---- 4 files changed, 45 insertions(+), 20 deletions(-) create mode 100644 modules/gitter/settings.go diff --git a/main.go b/main.go index 6c3ea1fe..6fcc09b5 100644 --- a/main.go +++ b/main.go @@ -223,7 +223,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := gitlab.NewSettingsFromYAML(wtf.Config) widget = gitlab.NewWidget(app, pages, settings) case "gitter": - widget = gitter.NewWidget(app, pages) + settings := gitter.NewSettingsFromYAML(wtf.Config) + widget = gitter.NewWidget(app, pages, settings) case "gspreadsheets": widget = gspreadsheets.NewWidget(app) case "hackernews": diff --git a/modules/gitter/client.go b/modules/gitter/client.go index f3d635c2..0eec0343 100644 --- a/modules/gitter/client.go +++ b/modules/gitter/client.go @@ -5,18 +5,16 @@ import ( "encoding/json" "fmt" "github.com/wtfutil/wtf/logger" - "github.com/wtfutil/wtf/wtf" "io" "io/ioutil" "net/http" - "os" "strconv" ) -func GetMessages(roomId string, numberOfMessages int) ([]Message, error) { +func GetMessages(roomId string, numberOfMessages int, apiToken string) ([]Message, error) { var messages []Message - resp, err := apiRequest("rooms/" + roomId + "/chatMessages?limit=" + strconv.Itoa(numberOfMessages)) + resp, err := apiRequest("rooms/"+roomId+"/chatMessages?limit="+strconv.Itoa(numberOfMessages), apiToken) if err != nil { return nil, err } @@ -26,10 +24,10 @@ func GetMessages(roomId string, numberOfMessages int) ([]Message, error) { return messages, nil } -func GetRoom(roomUri string) (*Room, error) { +func GetRoom(roomUri, apiToken string) (*Room, error) { var rooms Rooms - resp, err := apiRequest("rooms?q=" + roomUri) + resp, err := apiRequest("rooms?q="+roomUri, apiToken) if err != nil { return nil, err } @@ -52,9 +50,9 @@ var ( apiBaseURL = "https://api.gitter.im/v1/" ) -func apiRequest(path string) (*http.Response, error) { +func apiRequest(path, apiToken string) (*http.Response, error) { req, err := http.NewRequest("GET", apiBaseURL+path, nil) - bearer := fmt.Sprintf("Bearer %s", apiToken()) + bearer := fmt.Sprintf("Bearer %s", apiToken) req.Header.Add("Authorization", bearer) httpClient := &http.Client{} @@ -86,10 +84,3 @@ func parseJson(obj interface{}, text io.Reader) { } } } - -func apiToken() string { - return wtf.Config.UString( - "wtf.mods.gitter.apiToken", - os.Getenv("WTF_GITTER_API_TOKEN"), - ) -} diff --git a/modules/gitter/settings.go b/modules/gitter/settings.go new file mode 100644 index 00000000..6abdefd7 --- /dev/null +++ b/modules/gitter/settings.go @@ -0,0 +1,30 @@ +package gitter + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiToken string + numberOfMessages int + roomURI string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.gitter") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiToken: localConfig.UString("apiToken", os.Getenv("WTF_GITTER_API_TOKEN")), + numberOfMessages: localConfig.UInt("numberOfMessages", 10), + roomURI: localConfig.UString("roomUri", "wtfutil/Lobby"), + } + + return &settings +} diff --git a/modules/gitter/widget.go b/modules/gitter/widget.go index 89dbb03a..80b54e95 100644 --- a/modules/gitter/widget.go +++ b/modules/gitter/widget.go @@ -26,12 +26,15 @@ type Widget struct { messages []Message selected int + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Gitter", "gitter", true), + + settings: settings, } widget.HelpfulWidget.SetView(widget.View) @@ -51,7 +54,7 @@ func (widget *Widget) Refresh() { return } - room, err := GetRoom(wtf.Config.UString("wtf.mods.gitter.roomUri", "wtfutil/Lobby")) + room, err := GetRoom(widget.settings.roomURI, widget.settings.apiToken) if err != nil { widget.View.SetWrap(true) widget.View.SetTitle(widget.Name()) @@ -63,7 +66,7 @@ func (widget *Widget) Refresh() { return } - messages, err := GetMessages(room.ID, wtf.Config.UInt("wtf.mods.gitter.numberOfMessages", 10)) + messages, err := GetMessages(room.ID, widget.settings.numberOfMessages, widget.settings.apiToken) if err != nil { widget.View.SetWrap(true) @@ -86,7 +89,7 @@ func (widget *Widget) display() { widget.View.SetWrap(true) widget.View.Clear() - widget.View.SetTitle(widget.ContextualTitle(fmt.Sprintf("%s - %s", widget.Name(), wtf.Config.UString("wtf.mods.gitter.roomUri", "wtfutil/Lobby")))) + widget.View.SetTitle(widget.ContextualTitle(fmt.Sprintf("%s - %s", widget.Name(), widget.settings.roomURI))) widget.View.SetText(widget.contentFrom(widget.messages)) widget.View.Highlight(strconv.Itoa(widget.selected)).ScrollToHighlight() } From 4c6aacac5069f3ffa6edca26db2657b946bfe976 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 20:31:04 -0700 Subject: [PATCH 17/60] WTF-400 GSpreadsheets extracted to new config format --- main.go | 3 ++- modules/gspreadsheets/client.go | 9 ++++---- modules/gspreadsheets/settings.go | 36 +++++++++++++++++++++++++++++++ modules/gspreadsheets/widget.go | 13 ++++++----- 4 files changed, 50 insertions(+), 11 deletions(-) create mode 100644 modules/gspreadsheets/settings.go diff --git a/main.go b/main.go index 6fcc09b5..f8094e2a 100644 --- a/main.go +++ b/main.go @@ -226,7 +226,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := gitter.NewSettingsFromYAML(wtf.Config) widget = gitter.NewWidget(app, pages, settings) case "gspreadsheets": - widget = gspreadsheets.NewWidget(app) + settings := gspreadsheets.NewSettingsFromYAML(wtf.Config) + widget = gspreadsheets.NewWidget(app, settings) case "hackernews": widget = hackernews.NewWidget(app, pages) case "ipapi": diff --git a/modules/gspreadsheets/client.go b/modules/gspreadsheets/client.go index 12b6caf0..929f9748 100644 --- a/modules/gspreadsheets/client.go +++ b/modules/gspreadsheets/client.go @@ -26,10 +26,10 @@ import ( /* -------------------- Exported Functions -------------------- */ -func Fetch() ([]*sheets.ValueRange, error) { +func (widget *Widget) Fetch() ([]*sheets.ValueRange, error) { ctx := context.Background() - secretPath, _ := wtf.ExpandHomeDir(wtf.Config.UString("wtf.mods.gspreadsheets.secretFile")) + secretPath, _ := wtf.ExpandHomeDir(widget.settings.secretFile) b, err := ioutil.ReadFile(secretPath) if err != nil { @@ -51,14 +51,13 @@ func Fetch() ([]*sheets.ValueRange, error) { return nil, err } - cells := wtf.ToStrs(wtf.Config.UList("wtf.mods.gspreadsheets.cells.addresses")) - documentId := wtf.Config.UString("wtf.mods.gspreadsheets.sheetId") + cells := wtf.ToStrs(widget.settings.cellAddresses) addresses := strings.Join(cells[:], ";") responses := make([]*sheets.ValueRange, len(cells)) for i := 0; i < len(cells); i++ { - resp, err := srv.Spreadsheets.Values.Get(documentId, cells[i]).Do() + resp, err := srv.Spreadsheets.Values.Get(widget.settings.sheetID, cells[i]).Do() if err != nil { log.Fatalf("Error fetching cells %s", addresses) return nil, err diff --git a/modules/gspreadsheets/settings.go b/modules/gspreadsheets/settings.go new file mode 100644 index 00000000..adea7b61 --- /dev/null +++ b/modules/gspreadsheets/settings.go @@ -0,0 +1,36 @@ +package gspreadsheets + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + values string +} + +type Settings struct { + colors + common *cfg.Common + + cellAddresses []interface{} + cellNames []interface{} + secretFile string + sheetID string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.gspreadsheets") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + cellNames: localConfig.UList("cells.names"), + secretFile: localConfig.UString("secretFile"), + sheetID: localConfig.UString("sheetId"), + } + + settings.colors.values = localConfig.UString("colors.values", "green") + + return &settings +} diff --git a/modules/gspreadsheets/widget.go b/modules/gspreadsheets/widget.go index c2d9a5ba..448b06f4 100644 --- a/modules/gspreadsheets/widget.go +++ b/modules/gspreadsheets/widget.go @@ -10,11 +10,15 @@ import ( type Widget struct { wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "Google Spreadsheets", "gspreadsheets", false), + + settings: settings, } return &widget @@ -23,7 +27,7 @@ func NewWidget(app *tview.Application) *Widget { /* -------------------- Exported Functions -------------------- */ func (widget *Widget) Refresh() { - cells, _ := Fetch() + cells, _ := widget.Fetch() widget.View.SetText(widget.contentFrom(cells)) } @@ -35,12 +39,11 @@ func (widget *Widget) contentFrom(valueRanges []*sheets.ValueRange) string { return "error 1" } - valuesColor := wtf.Config.UString("wtf.mods.gspreadsheets.colors.values", "green") res := "" - cells := wtf.ToStrs(wtf.Config.UList("wtf.mods.gspreadsheets.cells.names")) + cells := wtf.ToStrs(widget.settings.cellNames) for i := 0; i < len(valueRanges); i++ { - res = res + fmt.Sprintf("%s\t[%s]%s\n", cells[i], valuesColor, valueRanges[i].Values[0][0]) + res = res + fmt.Sprintf("%s\t[%s]%s\n", cells[i], widget.settings.colors.values, valueRanges[i].Values[0][0]) } return res From 92c2cfc498021d903664020565e4b8bd0dbed9d3 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 20:39:39 -0700 Subject: [PATCH 18/60] WTF-400 HackerNews extracted to new config format --- main.go | 3 ++- modules/hackernews/settings.go | 26 ++++++++++++++++++++++++++ modules/hackernews/widget.go | 12 +++++++----- 3 files changed, 35 insertions(+), 6 deletions(-) create mode 100644 modules/hackernews/settings.go diff --git a/main.go b/main.go index f8094e2a..cef1dd01 100644 --- a/main.go +++ b/main.go @@ -229,7 +229,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := gspreadsheets.NewSettingsFromYAML(wtf.Config) widget = gspreadsheets.NewWidget(app, settings) case "hackernews": - widget = hackernews.NewWidget(app, pages) + settings := hackernews.NewSettingsFromYAML(wtf.Config) + widget = hackernews.NewWidget(app, pages, settings) case "ipapi": widget = ipapi.NewWidget(app) case "ipinfo": diff --git a/modules/hackernews/settings.go b/modules/hackernews/settings.go new file mode 100644 index 00000000..4a50cf4a --- /dev/null +++ b/modules/hackernews/settings.go @@ -0,0 +1,26 @@ +package hackernews + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + numberOfStories int + storyType string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.hackernews") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + numberOfStories: localConfig.UInt("numberOfStories", 10), + storyType: localConfig.UString("storyType", "top"), + } + + return &settings +} diff --git a/modules/hackernews/widget.go b/modules/hackernews/widget.go index be19ab36..5c1f4bb5 100644 --- a/modules/hackernews/widget.go +++ b/modules/hackernews/widget.go @@ -32,12 +32,15 @@ type Widget struct { stories []Story selected int + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Hacker News", "hackernews", true), + + settings: settings, } widget.HelpfulWidget.SetView(widget.View) @@ -57,7 +60,7 @@ func (widget *Widget) Refresh() { return } - storyIds, err := GetStories(wtf.Config.UString("wtf.mods.hackernews.storyType", "top")) + storyIds, err := GetStories(widget.settings.storyType) if storyIds == nil { return } @@ -68,8 +71,7 @@ func (widget *Widget) Refresh() { widget.View.SetText(err.Error()) } else { var stories []Story - numberOfStoriesToDisplay := wtf.Config.UInt("wtf.mods.hackernews.numberOfStories", 10) - for idx := 0; idx < numberOfStoriesToDisplay; idx++ { + for idx := 0; idx < widget.settings.numberOfStories; idx++ { story, e := GetStory(storyIds[idx]) if e != nil { panic(e) @@ -94,7 +96,7 @@ func (widget *Widget) display() { widget.View.SetWrap(false) widget.View.Clear() - widget.View.SetTitle(widget.ContextualTitle(fmt.Sprintf("%s - %sstories", widget.Name(), wtf.Config.UString("wtf.mods.hackernews.storyType", "top")))) + widget.View.SetTitle(widget.ContextualTitle(fmt.Sprintf("%s - %sstories", widget.Name(), widget.settings.storyType))) widget.View.SetText(widget.contentFrom(widget.stories)) widget.View.Highlight(strconv.Itoa(widget.selected)).ScrollToHighlight() } From 0b6a589827362bb0364164290479287fe55c6703 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 20:53:33 -0700 Subject: [PATCH 19/60] WTF-400 IPAPI extracted to new config format --- main.go | 3 ++- modules/ipaddresses/ipapi/settings.go | 29 +++++++++++++++++++++++++++ modules/ipaddresses/ipapi/widget.go | 24 ++++++++-------------- 3 files changed, 39 insertions(+), 17 deletions(-) create mode 100644 modules/ipaddresses/ipapi/settings.go diff --git a/main.go b/main.go index cef1dd01..031b7643 100644 --- a/main.go +++ b/main.go @@ -232,7 +232,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := hackernews.NewSettingsFromYAML(wtf.Config) widget = hackernews.NewWidget(app, pages, settings) case "ipapi": - widget = ipapi.NewWidget(app) + settings := ipapi.NewSettingsFromYAML(wtf.Config) + widget = ipapi.NewWidget(app, settings) case "ipinfo": widget = ipinfo.NewWidget(app) case "jenkins": diff --git a/modules/ipaddresses/ipapi/settings.go b/modules/ipaddresses/ipapi/settings.go new file mode 100644 index 00000000..a78af00c --- /dev/null +++ b/modules/ipaddresses/ipapi/settings.go @@ -0,0 +1,29 @@ +package ipapi + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + name string + value string +} + +type Settings struct { + colors + common *cfg.Common +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.ipapi") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + settings.colors.name = localConfig.UString("colors.name", "red") + settings.colors.value = localConfig.UString("colors.value", "white") + + return &settings +} diff --git a/modules/ipaddresses/ipapi/widget.go b/modules/ipaddresses/ipapi/widget.go index 8a9bfc48..53dec853 100644 --- a/modules/ipaddresses/ipapi/widget.go +++ b/modules/ipaddresses/ipapi/widget.go @@ -15,10 +15,9 @@ import ( // Widget widget struct type Widget struct { wtf.TextWidget - result string - colors struct { - name, value string - } + + result string + settings *Settings } type ipinfo struct { @@ -37,15 +36,15 @@ type ipinfo struct { } // NewWidget constructor -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "IPInfo", "ipapi", false), + + settings: settings, } widget.View.SetWrap(false) - widget.config() - return &widget } @@ -80,13 +79,6 @@ func (widget *Widget) ipinfo() { widget.setResult(&info) } -// read module configs -func (widget *Widget) config() { - nameColor, valueColor := wtf.Config.UString("wtf.mods.ipinfo.colors.name", "red"), wtf.Config.UString("wtf.mods.ipinfo.colors.value", "white") - widget.colors.name = nameColor - widget.colors.value = valueColor -} - func (widget *Widget) setResult(info *ipinfo) { resultTemplate, _ := template.New("ipinfo_result").Parse( formatableText("IP Address", "Ip") + @@ -104,8 +96,8 @@ func (widget *Widget) setResult(info *ipinfo) { resultBuffer := new(bytes.Buffer) resultTemplate.Execute(resultBuffer, map[string]string{ - "nameColor": widget.colors.name, - "valueColor": widget.colors.value, + "nameColor": widget.settings.colors.name, + "valueColor": widget.settings.colors.value, "Ip": info.Query, "ISP": info.ISP, "AS": info.AS, From d4558f533a5e25a46f8ab311769bed89833c1b89 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Sun, 14 Apr 2019 21:05:36 -0700 Subject: [PATCH 20/60] WTF-400 IPInfo extracted to new config format --- main.go | 3 ++- modules/ipaddresses/ipinfo/settings.go | 29 ++++++++++++++++++++++++++ modules/ipaddresses/ipinfo/widget.go | 23 +++++++------------- 3 files changed, 39 insertions(+), 16 deletions(-) create mode 100644 modules/ipaddresses/ipinfo/settings.go diff --git a/main.go b/main.go index 031b7643..43544ae8 100644 --- a/main.go +++ b/main.go @@ -235,7 +235,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := ipapi.NewSettingsFromYAML(wtf.Config) widget = ipapi.NewWidget(app, settings) case "ipinfo": - widget = ipinfo.NewWidget(app) + settings := ipinfo.NewSettingsFromYAML(wtf.Config) + widget = ipinfo.NewWidget(app, settings) case "jenkins": widget = jenkins.NewWidget(app, pages) case "jira": diff --git a/modules/ipaddresses/ipinfo/settings.go b/modules/ipaddresses/ipinfo/settings.go new file mode 100644 index 00000000..445bc2ca --- /dev/null +++ b/modules/ipaddresses/ipinfo/settings.go @@ -0,0 +1,29 @@ +package ipinfo + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + name string + value string +} + +type Settings struct { + colors + common *cfg.Common +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.ipinfo") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + settings.colors.name = localConfig.UString("colors.name", "red") + settings.colors.value = localConfig.UString("colors.value", "white") + + return &settings +} diff --git a/modules/ipaddresses/ipinfo/widget.go b/modules/ipaddresses/ipinfo/widget.go index 7ee92a4b..6d9135b6 100644 --- a/modules/ipaddresses/ipinfo/widget.go +++ b/modules/ipaddresses/ipinfo/widget.go @@ -13,10 +13,9 @@ import ( type Widget struct { wtf.TextWidget - result string - colors struct { - name, value string - } + + result string + settings *Settings } type ipinfo struct { @@ -30,15 +29,15 @@ type ipinfo struct { Organization string `json:"org"` } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "IPInfo", "ipinfo", false), + + settings: settings, } widget.View.SetWrap(false) - widget.config() - return &widget } @@ -75,12 +74,6 @@ func (widget *Widget) ipinfo() { widget.setResult(&info) } -// read module configs -func (widget *Widget) config() { - widget.colors.name = wtf.Config.UString("wtf.mods.ipinfo.colors.name", "white") - widget.colors.value = wtf.Config.UString("wtf.mods.ipinfo.colors.value", "white") -} - func (widget *Widget) setResult(info *ipinfo) { resultTemplate, _ := template.New("ipinfo_result").Parse( formatableText("IP", "Ip") + @@ -95,8 +88,8 @@ func (widget *Widget) setResult(info *ipinfo) { resultBuffer := new(bytes.Buffer) resultTemplate.Execute(resultBuffer, map[string]string{ - "nameColor": widget.colors.name, - "valueColor": widget.colors.value, + "nameColor": widget.settings.colors.name, + "valueColor": widget.settings.colors.value, "Ip": info.Ip, "Hostname": info.Hostname, "City": info.City, From 9b41e6e732d6fade2b50c624e6211fffb5a77be3 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Mon, 15 Apr 2019 09:48:32 -0700 Subject: [PATCH 21/60] WTF-400 Jenkins extracted to new config format --- main.go | 3 ++- modules/jenkins/client.go | 7 ++----- modules/jenkins/settings.go | 34 ++++++++++++++++++++++++++++++++++ modules/jenkins/widget.go | 33 ++++++++++++--------------------- 4 files changed, 50 insertions(+), 27 deletions(-) create mode 100644 modules/jenkins/settings.go diff --git a/main.go b/main.go index 43544ae8..ea41c6e9 100644 --- a/main.go +++ b/main.go @@ -238,7 +238,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := ipinfo.NewSettingsFromYAML(wtf.Config) widget = ipinfo.NewWidget(app, settings) case "jenkins": - widget = jenkins.NewWidget(app, pages) + settings := jenkins.NewSettingsFromYAML(wtf.Config) + widget = jenkins.NewWidget(app, pages, settings) case "jira": widget = jira.NewWidget(app, pages) case "logger": diff --git a/modules/jenkins/client.go b/modules/jenkins/client.go index 97105c86..7d7cfeb0 100644 --- a/modules/jenkins/client.go +++ b/modules/jenkins/client.go @@ -9,11 +9,9 @@ import ( "net/http" "net/url" "strings" - - "github.com/wtfutil/wtf/wtf" ) -func Create(jenkinsURL string, username string, apiKey string) (*View, error) { +func (widget *Widget) Create(jenkinsURL string, username string, apiKey string) (*View, error) { const apiSuffix = "api/json?pretty=true" parsedSuffix, err := url.Parse(apiSuffix) if err != nil { @@ -29,10 +27,9 @@ func Create(jenkinsURL string, username string, apiKey string) (*View, error) { req, _ := http.NewRequest("GET", jenkinsAPIURL.String(), nil) req.SetBasicAuth(username, apiKey) - verifyServerCertificate := wtf.Config.UBool("wtf.mods.jenkins.verifyServerCertificate", true) httpClient := &http.Client{Transport: &http.Transport{ TLSClientConfig: &tls.Config{ - InsecureSkipVerify: !verifyServerCertificate, + InsecureSkipVerify: !widget.settings.verifyServerCertificate, }, Proxy: http.ProxyFromEnvironment, }, diff --git a/modules/jenkins/settings.go b/modules/jenkins/settings.go new file mode 100644 index 00000000..20f9c22c --- /dev/null +++ b/modules/jenkins/settings.go @@ -0,0 +1,34 @@ +package jenkins + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiKey string + successBallColor string + url string + user string + verifyServerCertificate bool +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.jenkins") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_JENKINS_API_KEY")), + successBallColor: localConfig.UString("successBallColor", "blue"), + url: localConfig.UString("url"), + user: localConfig.UString("user"), + verifyServerCertificate: localConfig.UBool("verifyServerCertificate", true), + } + + return &settings +} diff --git a/modules/jenkins/widget.go b/modules/jenkins/widget.go index c4446744..51ec7b67 100644 --- a/modules/jenkins/widget.go +++ b/modules/jenkins/widget.go @@ -2,11 +2,11 @@ package jenkins import ( "fmt" + "strconv" + "github.com/gdamore/tcell" "github.com/rivo/tview" "github.com/wtfutil/wtf/wtf" - "os" - "strconv" ) const HelpText = ` @@ -27,14 +27,17 @@ type Widget struct { wtf.HelpfulWidget wtf.TextWidget - view *View selected int + settings *Settings + view *View } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Jenkins", "jenkins", true), + + settings: settings, } widget.HelpfulWidget.SetView(widget.View) @@ -54,10 +57,10 @@ func (widget *Widget) Refresh() { return } - view, err := Create( - wtf.Config.UString("wtf.mods.jenkins.url"), - wtf.Config.UString("wtf.mods.jenkins.user"), - widget.apiKey(), + view, err := widget.Create( + widget.settings.url, + widget.settings.user, + widget.settings.apiKey, ) widget.view = view @@ -85,13 +88,6 @@ func (widget *Widget) display() { widget.View.Highlight(strconv.Itoa(widget.selected)).ScrollToHighlight() } -func (widget *Widget) apiKey() string { - return wtf.Config.UString( - "wtf.mods.jenkins.apiKey", - os.Getenv("WTF_JENKINS_API_KEY"), - ) -} - func (widget *Widget) contentFrom(view *View) string { var str string for idx, job := range view.Jobs { @@ -121,12 +117,7 @@ func (widget *Widget) jobColor(job *Job) string { switch job.Color { case "blue": // Override color if successBallColor boolean param provided in config - ballColor := wtf.Config.UString("wtf.mods.jenkins.successBallColor", "blue") - if ballColor != "blue" { - return ballColor - } else { - return "blue" - } + return widget.settings.successBallColor case "red": return "red" default: From fea83a38b265af4e531838a32a7133ed923b9bcc Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Mon, 15 Apr 2019 10:46:41 -0700 Subject: [PATCH 22/60] WTF-400 Jira extracted to new config format --- main.go | 3 +- modules/jira/client.go | 23 ++++--------- modules/jira/settings.go | 74 ++++++++++++++++++++++++++++++++++++++++ modules/jira/widget.go | 42 +++++++++-------------- wtf/utils.go | 3 -- 5 files changed, 98 insertions(+), 47 deletions(-) create mode 100644 modules/jira/settings.go diff --git a/main.go b/main.go index ea41c6e9..ae77eac6 100644 --- a/main.go +++ b/main.go @@ -241,7 +241,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := jenkins.NewSettingsFromYAML(wtf.Config) widget = jenkins.NewWidget(app, pages, settings) case "jira": - widget = jira.NewWidget(app, pages) + settings := jira.NewSettingsFromYAML(wtf.Config) + widget = jira.NewWidget(app, pages, settings) case "logger": widget = logger.NewWidget(app) case "mercurial": diff --git a/modules/jira/client.go b/modules/jira/client.go index df639251..15818076 100644 --- a/modules/jira/client.go +++ b/modules/jira/client.go @@ -9,13 +9,10 @@ import ( "io/ioutil" "net/http" "net/url" - "os" "strings" - - "github.com/wtfutil/wtf/wtf" ) -func IssuesFor(username string, projects []string, jql string) (*SearchResult, error) { +func (widget *Widget) IssuesFor(username string, projects []string, jql string) (*SearchResult, error) { query := []string{} var projQuery = getProjectQuery(projects) @@ -37,7 +34,7 @@ func IssuesFor(username string, projects []string, jql string) (*SearchResult, e url := fmt.Sprintf("/rest/api/2/search?%s", v.Encode()) - resp, err := jiraRequest(url) + resp, err := widget.jiraRequest(url) if err != nil { return &SearchResult{}, err } @@ -54,26 +51,18 @@ func buildJql(key string, value string) string { /* -------------------- Unexported Functions -------------------- */ -func apiKey() string { - return wtf.Config.UString( - "wtf.mods.jira.apiKey", - os.Getenv("WTF_JIRA_API_KEY"), - ) -} - -func jiraRequest(path string) (*http.Response, error) { - url := fmt.Sprintf("%s%s", wtf.Config.UString("wtf.mods.jira.domain"), path) +func (widget *Widget) jiraRequest(path string) (*http.Response, error) { + url := fmt.Sprintf("%s%s", widget.settings.domain, path) req, err := http.NewRequest("GET", url, nil) if err != nil { return nil, err } - req.SetBasicAuth(wtf.Config.UString("wtf.mods.jira.email"), apiKey()) + req.SetBasicAuth(widget.settings.email, widget.settings.apiKey) - verifyServerCertificate := wtf.Config.UBool("wtf.mods.jira.verifyServerCertificate", true) httpClient := &http.Client{Transport: &http.Transport{ TLSClientConfig: &tls.Config{ - InsecureSkipVerify: !verifyServerCertificate, + InsecureSkipVerify: !widget.settings.verifyServerCertificate, }, Proxy: http.ProxyFromEnvironment, }, diff --git a/modules/jira/settings.go b/modules/jira/settings.go new file mode 100644 index 00000000..a31c6f04 --- /dev/null +++ b/modules/jira/settings.go @@ -0,0 +1,74 @@ +package jira + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + rows struct { + even string + odd string + } +} + +type Settings struct { + colors + common *cfg.Common + + apiKey string + domain string + email string + jql string + projects []string + username string + verifyServerCertificate bool +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.jira") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_JIRA_API_KEY")), + domain: localConfig.UString("domain"), + email: localConfig.UString("email"), + jql: localConfig.UString("jql"), + username: localConfig.UString("username"), + verifyServerCertificate: localConfig.UBool("verifyServerCertificate", true), + } + + settings.colors.rows.even = localConfig.UString("colors.even", "lightblue") + settings.colors.rows.odd = localConfig.UString("colors.odd", "white") + + settings.projects = settings.arrayifyProjects(localConfig) + + return &settings +} + +/* -------------------- Unexported functions -------------------- */ + +// arrayifyProjects figures out if we're dealing with a single project or an array of projects +func (settings *Settings) arrayifyProjects(localConfig *config.Config) []string { + projects := []string{} + + // Single project + project, err := localConfig.String("project") + if err == nil { + projects = append(projects, project) + return projects + } + + // Array of projects + projectList := localConfig.UList("project") + for _, projectName := range projectList { + if project, ok := projectName.(string); ok { + projects = append(projects, project) + } + } + + return projects +} diff --git a/modules/jira/widget.go b/modules/jira/widget.go index ef260a12..06c1b887 100644 --- a/modules/jira/widget.go +++ b/modules/jira/widget.go @@ -28,12 +28,15 @@ type Widget struct { result *SearchResult selected int + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Jira", "jira", true), + + settings: settings, } widget.HelpfulWidget.SetView(widget.View) @@ -48,10 +51,10 @@ func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { /* -------------------- Exported Functions -------------------- */ func (widget *Widget) Refresh() { - searchResult, err := IssuesFor( - wtf.Config.UString("wtf.mods.jira.username"), - getProjects(), - wtf.Config.UString("wtf.mods.jira.jql", ""), + searchResult, err := widget.IssuesFor( + widget.settings.username, + widget.settings.projects, + widget.settings.jql, ) if err != nil { @@ -74,7 +77,7 @@ func (widget *Widget) display() { } widget.View.SetWrap(false) - str := fmt.Sprintf("%s- [green]%s[white]", widget.Name(), wtf.Config.UString("wtf.mods.jira.project")) + str := fmt.Sprintf("%s- [green]%s[white]", widget.Name(), widget.settings.projects) widget.View.Clear() widget.View.SetTitle(widget.ContextualTitle(str)) @@ -100,7 +103,7 @@ func (widget *Widget) openItem() { sel := widget.selected if sel >= 0 && widget.result != nil && sel < len(widget.result.Issues) { issue := &widget.result.Issues[widget.selected] - wtf.OpenFile(wtf.Config.UString("wtf.mods.jira.domain") + "/browse/" + issue.Key) + wtf.OpenFile(widget.settings.domain + "/browse/" + issue.Key) } } @@ -137,7 +140,12 @@ func (widget *Widget) rowColor(idx int) string { if widget.View.HasFocus() && (idx == widget.selected) { return wtf.DefaultFocussedRowColor() } - return wtf.RowColor("jira", idx) + + if idx%2 == 0 { + return widget.settings.colors.rows.even + } + + return widget.settings.colors.rows.odd } func (widget *Widget) issueTypeColor(issue *Issue) string { @@ -153,24 +161,6 @@ func (widget *Widget) issueTypeColor(issue *Issue) string { } } -func getProjects() []string { - // see if project is set to a single string - configPath := "wtf.mods.jira.project" - singleProject, err := wtf.Config.String(configPath) - if err == nil { - return []string{singleProject} - } - // else, assume list - projList := wtf.Config.UList(configPath) - var ret []string - for _, proj := range projList { - if str, ok := proj.(string); ok { - ret = append(ret, str) - } - } - return ret -} - func (widget *Widget) keyboardIntercept(event *tcell.EventKey) *tcell.EventKey { switch string(event.Rune()) { case "/": diff --git a/wtf/utils.go b/wtf/utils.go index c8e8ae01..205ea09a 100644 --- a/wtf/utils.go +++ b/wtf/utils.go @@ -136,10 +136,7 @@ func ReadFileBytes(filePath string) ([]byte, error) { } func RightAlignFormat(view *tview.TextView) string { - //mutex := &sync.Mutex{} - //mutex.Lock() _, _, w, _ := view.GetInnerRect() - //mutex.Unlock() return fmt.Sprintf("%%%ds", w-1) } From 8bc217e9a129a7a8ecde0be05c479675a7afce5d Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Mon, 15 Apr 2019 20:29:45 -0700 Subject: [PATCH 23/60] WTF-400 Logger extracted to new config format --- cfg/config_files.go | 6 ++---- logger/log.go | 5 +++-- logger/settings.go | 20 ++++++++++++++++++++ main.go | 3 ++- 4 files changed, 27 insertions(+), 7 deletions(-) create mode 100644 logger/settings.go diff --git a/cfg/config_files.go b/cfg/config_files.go index dac769e1..284dbae8 100644 --- a/cfg/config_files.go +++ b/cfg/config_files.go @@ -6,7 +6,7 @@ import ( "os" "github.com/olebedev/config" - "github.com/wtfutil/wtf/logger" + // "github.com/wtfutil/wtf/logger" "github.com/wtfutil/wtf/wtf" ) @@ -38,15 +38,13 @@ func MigrateOldConfig() { err := Copy(srcDir, destDir) if err != nil { panic(err) - } else { - logger.Log(fmt.Sprintf("Copied old config from %s to %s", srcDir, destDir)) } // Delete the old directory if the new one exists if _, err := os.Stat(destDir); err == nil { err := os.RemoveAll(srcDir) if err != nil { - logger.Log(err.Error()) + fmt.Println(err) } } } diff --git a/logger/log.go b/logger/log.go index 0e40dc0d..b786e122 100644 --- a/logger/log.go +++ b/logger/log.go @@ -2,7 +2,6 @@ package logger import ( "fmt" - //"io/ioutil" "log" "os" "path/filepath" @@ -18,13 +17,15 @@ type Widget struct { wtf.TextWidget filePath string + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "Logs", "logger", true), filePath: logFilePath(), + settings: settings, } return &widget diff --git a/logger/settings.go b/logger/settings.go new file mode 100644 index 00000000..f5787b98 --- /dev/null +++ b/logger/settings.go @@ -0,0 +1,20 @@ +package logger + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + filePath string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + return &settings +} diff --git a/main.go b/main.go index ae77eac6..f8ab6313 100644 --- a/main.go +++ b/main.go @@ -244,7 +244,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := jira.NewSettingsFromYAML(wtf.Config) widget = jira.NewWidget(app, pages, settings) case "logger": - widget = logger.NewWidget(app) + settings := logger.NewSettingsFromYAML(wtf.Config) + widget = logger.NewWidget(app, settings) case "mercurial": widget = mercurial.NewWidget(app, pages) case "nbascore": From 3259e16adaf99f0f8d7fdd772ff32cd624976eec Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Mon, 15 Apr 2019 20:44:31 -0700 Subject: [PATCH 24/60] WTF-400 Mercurial extracted to new config format --- main.go | 3 ++- modules/mercurial/hg_repo.go | 10 ++++------ modules/mercurial/settings.go | 28 ++++++++++++++++++++++++++++ modules/mercurial/widget.go | 18 ++++++++++-------- 4 files changed, 44 insertions(+), 15 deletions(-) create mode 100644 modules/mercurial/settings.go diff --git a/main.go b/main.go index f8ab6313..704248c3 100644 --- a/main.go +++ b/main.go @@ -247,7 +247,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := logger.NewSettingsFromYAML(wtf.Config) widget = logger.NewWidget(app, settings) case "mercurial": - widget = mercurial.NewWidget(app, pages) + settings := mercurial.NewSettingsFromYAML(wtf.Config) + widget = mercurial.NewWidget(app, pages, settings) case "nbascore": widget = nbascore.NewWidget(app, pages) case "newrelic": diff --git a/modules/mercurial/hg_repo.go b/modules/mercurial/hg_repo.go index 27774c96..ae53a21f 100644 --- a/modules/mercurial/hg_repo.go +++ b/modules/mercurial/hg_repo.go @@ -19,13 +19,13 @@ type MercurialRepo struct { Path string } -func NewMercurialRepo(repoPath string) *MercurialRepo { +func NewMercurialRepo(repoPath string, commitCount int, commitFormat string) *MercurialRepo { repo := MercurialRepo{Path: repoPath} repo.Branch = strings.TrimSpace(repo.branch()) repo.Bookmark = strings.TrimSpace(repo.bookmark()) repo.ChangedFiles = repo.changedFiles() - repo.Commits = repo.commits() + repo.Commits = repo.commits(commitCount, commitFormat) repo.Repository = strings.TrimSpace(repo.Path) return &repo @@ -61,10 +61,8 @@ func (repo *MercurialRepo) changedFiles() []string { return data } -func (repo *MercurialRepo) commits() []string { - numStr := fmt.Sprintf("-l %d", wtf.Config.UInt("wtf.mods.mercurial.commitCount", 10)) - - commitFormat := wtf.Config.UString("wtf.mods.mercurial.commitFormat", "[forestgreen]{rev}:{phase} [white]{desc|firstline|strip} [grey]{author|person} {date|age}[white]") +func (repo *MercurialRepo) commits(commitCount int, commitFormat string) []string { + numStr := fmt.Sprintf("-l %d", commitCount) commitStr := fmt.Sprintf("--template=\"%s\n\"", commitFormat) arg := []string{"log", repo.repoPath(), numStr, commitStr} diff --git a/modules/mercurial/settings.go b/modules/mercurial/settings.go new file mode 100644 index 00000000..a8a48afb --- /dev/null +++ b/modules/mercurial/settings.go @@ -0,0 +1,28 @@ +package mercurial + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + commitCount int + commitFormat string + repositories []interface{} +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.mercurial") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + commitCount: localConfig.UInt("commitCount", 10), + commitFormat: localConfig.UString("commitFormat", "[forestgreen]{rev}:{phase} [white]{desc|firstline|strip} [grey]{author|person} {date|age}[white]"), + repositories: localConfig.UList("repositories"), + } + + return &settings +} diff --git a/modules/mercurial/widget.go b/modules/mercurial/widget.go index 2947fef7..b42d780e 100644 --- a/modules/mercurial/widget.go +++ b/modules/mercurial/widget.go @@ -28,19 +28,21 @@ type Widget struct { wtf.MultiSourceWidget wtf.TextWidget - app *tview.Application - Data []*MercurialRepo - pages *tview.Pages + app *tview.Application + Data []*MercurialRepo + pages *tview.Pages + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), MultiSourceWidget: wtf.NewMultiSourceWidget("mercurial", "repository", "repositories"), TextWidget: wtf.NewTextWidget(app, "Mercurial", "mercurial", true), - app: app, - pages: pages, + app: app, + pages: pages, + settings: settings, } widget.LoadSources() @@ -79,7 +81,7 @@ func (widget *Widget) Pull() { } func (widget *Widget) Refresh() { - repoPaths := wtf.ToStrs(wtf.Config.UList("wtf.mods.mercurial.repositories")) + repoPaths := wtf.ToStrs(widget.settings.repositories) widget.Data = widget.mercurialRepos(repoPaths) widget.display() @@ -156,7 +158,7 @@ func (widget *Widget) mercurialRepos(repoPaths []string) []*MercurialRepo { repos := []*MercurialRepo{} for _, repoPath := range repoPaths { - repo := NewMercurialRepo(repoPath) + repo := NewMercurialRepo(repoPath, widget.settings.commitCount, widget.settings.commitFormat) repos = append(repos, repo) } From 8ad8d942d0d44ff47c20bfde887394a3c192dc9d Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Mon, 15 Apr 2019 20:49:03 -0700 Subject: [PATCH 25/60] WTF-400 NBAScore extracted to new config format --- main.go | 3 ++- modules/nbascore/settings.go | 18 ++++++++++++++++++ modules/nbascore/widget.go | 9 +++++---- 3 files changed, 25 insertions(+), 5 deletions(-) create mode 100644 modules/nbascore/settings.go diff --git a/main.go b/main.go index 704248c3..e363fc02 100644 --- a/main.go +++ b/main.go @@ -250,7 +250,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := mercurial.NewSettingsFromYAML(wtf.Config) widget = mercurial.NewWidget(app, pages, settings) case "nbascore": - widget = nbascore.NewWidget(app, pages) + settings := nbascore.NewSettingsFromYAML(wtf.Config) + widget = nbascore.NewWidget(app, pages, settings) case "newrelic": widget = newrelic.NewWidget(app) case "opsgenie": diff --git a/modules/nbascore/settings.go b/modules/nbascore/settings.go new file mode 100644 index 00000000..763135be --- /dev/null +++ b/modules/nbascore/settings.go @@ -0,0 +1,18 @@ +package nbascore + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + return &settings +} diff --git a/modules/nbascore/widget.go b/modules/nbascore/widget.go index 242decb9..0525c1a7 100644 --- a/modules/nbascore/widget.go +++ b/modules/nbascore/widget.go @@ -22,22 +22,23 @@ const HelpText = ` type Widget struct { wtf.HelpfulWidget wtf.TextWidget - app *tview.Application - pages *tview.Pages + language string result string + settings *Settings } var offset = 0 -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "NBA Score", "nbascore", true), + + settings: settings, } widget.HelpfulWidget.SetView(widget.View) - widget.TextWidget.RefreshInt = 15 widget.View.SetInputCapture(widget.keyboardIntercept) widget.View.SetScrollable(true) From b6d845b73451fa178c197146710e5ccf52a7a440 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Mon, 15 Apr 2019 21:01:25 -0700 Subject: [PATCH 26/60] WTF-400 NewRelic extracted to new config format --- main.go | 3 ++- modules/newrelic/settings.go | 30 ++++++++++++++++++++++++++++++ modules/newrelic/widget.go | 21 +++++++++------------ modules/todo/settings.go | 3 ++- 4 files changed, 43 insertions(+), 14 deletions(-) create mode 100644 modules/newrelic/settings.go diff --git a/main.go b/main.go index e363fc02..370624ec 100644 --- a/main.go +++ b/main.go @@ -253,7 +253,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := nbascore.NewSettingsFromYAML(wtf.Config) widget = nbascore.NewWidget(app, pages, settings) case "newrelic": - widget = newrelic.NewWidget(app) + settings := newrelic.NewSettingsFromYAML(wtf.Config) + widget = newrelic.NewWidget(app, settings) case "opsgenie": widget = opsgenie.NewWidget(app) case "pagerduty": diff --git a/modules/newrelic/settings.go b/modules/newrelic/settings.go new file mode 100644 index 00000000..0971bf00 --- /dev/null +++ b/modules/newrelic/settings.go @@ -0,0 +1,30 @@ +package newrelic + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiKey string + applicationID int + deployCount int +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.newrelic") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_NEW_RELIC_API_KEY")), + applicationID: localConfig.UInt("applicationID"), + deployCount: localConfig.UInt("deployCount", 5), + } + + return &settings +} diff --git a/modules/newrelic/widget.go b/modules/newrelic/widget.go index 591426c5..1ed7be12 100644 --- a/modules/newrelic/widget.go +++ b/modules/newrelic/widget.go @@ -2,7 +2,6 @@ package newrelic import ( "fmt" - "os" "github.com/rivo/tview" "github.com/wtfutil/wtf/wtf" @@ -11,15 +10,20 @@ import ( type Widget struct { wtf.TextWidget - client *Client + + client *Client + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "New Relic", "newrelic", false), - client: NewClient(apiKey(), wtf.Config.UInt("wtf.mods.newrelic.applicationId")), + + settings: settings, } + widget.client = NewClient(widget.settings.apiKey, widget.settings.applicationID) + return &widget } @@ -81,7 +85,7 @@ func (widget *Widget) contentFrom(deploys []nr.ApplicationDeployment) string { revisions = append(revisions, deploy.Revision) - if len(revisions) == wtf.Config.UInt("wtf.mods.newrelic.deployCount", 5) { + if len(revisions) == widget.settings.deployCount { break } } @@ -89,10 +93,3 @@ func (widget *Widget) contentFrom(deploys []nr.ApplicationDeployment) string { return str } - -func apiKey() string { - return wtf.Config.UString( - "wtf.mods.newrelic.apiKey", - os.Getenv("WTF_NEW_RELIC_API_KEY"), - ) -} diff --git a/modules/todo/settings.go b/modules/todo/settings.go index 6632ff2b..98f4a0f7 100644 --- a/modules/todo/settings.go +++ b/modules/todo/settings.go @@ -15,7 +15,8 @@ func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { localConfig, _ := ymlConfig.Get("wtf.mods.todo") settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + filePath: localConfig.UString("filename"), } From ad156795886a86013a628bde9d2a6507043af327 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Mon, 15 Apr 2019 21:16:18 -0700 Subject: [PATCH 27/60] WTF-400 OpsGenie extracted to new config format --- main.go | 3 +- modules/opsgenie/client.go | 15 ++-------- modules/opsgenie/settings.go | 55 ++++++++++++++++++++++++++++++++++++ modules/opsgenie/widget.go | 35 +++++++---------------- 4 files changed, 70 insertions(+), 38 deletions(-) create mode 100644 modules/opsgenie/settings.go diff --git a/main.go b/main.go index 370624ec..93fb1510 100644 --- a/main.go +++ b/main.go @@ -256,7 +256,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := newrelic.NewSettingsFromYAML(wtf.Config) widget = newrelic.NewWidget(app, settings) case "opsgenie": - widget = opsgenie.NewWidget(app) + settings := opsgenie.NewSettingsFromYAML(wtf.Config) + widget = opsgenie.NewWidget(app, settings) case "pagerduty": widget = pagerduty.NewWidget(app) case "power": diff --git a/modules/opsgenie/client.go b/modules/opsgenie/client.go index 4e56bec9..928ad57e 100644 --- a/modules/opsgenie/client.go +++ b/modules/opsgenie/client.go @@ -4,9 +4,6 @@ import ( "encoding/json" "fmt" "net/http" - "os" - - "github.com/wtfutil/wtf/wtf" ) type OnCallResponse struct { @@ -29,11 +26,12 @@ type Parent struct { /* -------------------- Exported Functions -------------------- */ -func Fetch(scheduleIdentifierType string, schedules []string) ([]*OnCallResponse, error) { +func (widget *Widget) Fetch(scheduleIdentifierType string, schedules []string) ([]*OnCallResponse, error) { agregatedResponses := []*OnCallResponse{} + for _, sched := range schedules { scheduleUrl := fmt.Sprintf("https://api.opsgenie.com/v2/schedules/%s/on-calls?scheduleIdentifierType=%s&flat=true", sched, scheduleIdentifierType) - response, err := opsGenieRequest(scheduleUrl, apiKey()) + response, err := opsGenieRequest(scheduleUrl, widget.settings.apiKey) agregatedResponses = append(agregatedResponses, response) if err != nil { return nil, err @@ -44,13 +42,6 @@ func Fetch(scheduleIdentifierType string, schedules []string) ([]*OnCallResponse /* -------------------- Unexported Functions -------------------- */ -func apiKey() string { - return wtf.Config.UString( - "wtf.mods.opsgenie.apiKey", - os.Getenv("WTF_OPS_GENIE_API_KEY"), - ) -} - func opsGenieRequest(url string, apiKey string) (*OnCallResponse, error) { req, err := http.NewRequest("GET", url, nil) if err != nil { diff --git a/modules/opsgenie/settings.go b/modules/opsgenie/settings.go new file mode 100644 index 00000000..07ebc512 --- /dev/null +++ b/modules/opsgenie/settings.go @@ -0,0 +1,55 @@ +package opsgenie + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiKey string + displayEmpty bool + schedule []string + scheduleIdentifierType string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.opsgenie") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_OPS_GENIE_API_KEY")), + displayEmpty: localConfig.UBool("displayEmpty", true), + scheduleIdentifierType: localConfig.UString("scheduleIdentifierType", "id"), + } + + settings.schedule = settings.arrayifySchedules(localConfig) + + return &settings +} + +// arrayifySchedules figures out if we're dealing with a single project or an array of projects +func (settings *Settings) arrayifySchedules(localConfig *config.Config) []string { + schedules := []string{} + + // Single schedule + schedule, err := localConfig.String("schedule") + if err == nil { + schedules = append(schedules, schedule) + return schedules + } + + // Array of schedules + scheduleList := localConfig.UList("schedule") + for _, scheduleName := range scheduleList { + if schedule, ok := scheduleName.(string); ok { + schedules = append(schedules, schedule) + } + } + + return schedules +} diff --git a/modules/opsgenie/widget.go b/modules/opsgenie/widget.go index 717c5f34..26c051b8 100644 --- a/modules/opsgenie/widget.go +++ b/modules/opsgenie/widget.go @@ -10,11 +10,15 @@ import ( type Widget struct { wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "OpsGenie", "opsgenie", false), + + settings: settings, } return &widget @@ -23,10 +27,11 @@ func NewWidget(app *tview.Application) *Widget { /* -------------------- Exported Functions -------------------- */ func (widget *Widget) Refresh() { - data, err := Fetch( - wtf.Config.UString("wtf.mods.opsgenie.scheduleIdentifierType"), - getSchedules(), + data, err := widget.Fetch( + widget.settings.scheduleIdentifierType, + widget.settings.schedule, ) + widget.View.SetTitle(widget.ContextualTitle(widget.Name())) var content string @@ -43,31 +48,11 @@ func (widget *Widget) Refresh() { /* -------------------- Unexported Functions -------------------- */ -func getSchedules() []string { - // see if schedule is set to a single string - configPath := "wtf.mods.opsgenie.schedule" - singleSchedule, err := wtf.Config.String(configPath) - if err == nil { - return []string{singleSchedule} - } - // else, assume list - scheduleList := wtf.Config.UList(configPath) - var ret []string - for _, schedule := range scheduleList { - if str, ok := schedule.(string); ok { - ret = append(ret, str) - } - } - return ret -} - func (widget *Widget) contentFrom(onCallResponses []*OnCallResponse) string { str := "" - displayEmpty := wtf.Config.UBool("wtf.mods.opsgenie.displayEmpty", true) - for _, data := range onCallResponses { - if (len(data.OnCallData.Recipients) == 0) && (displayEmpty == false) { + if (len(data.OnCallData.Recipients) == 0) && (widget.settings.displayEmpty == false) { continue } From 265149ca1152a90ad4d73754d073536ff61d61d8 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Mon, 15 Apr 2019 21:38:10 -0700 Subject: [PATCH 28/60] WTF-400 Power extracted to new config format --- main.go | 3 ++- modules/power/settings.go | 20 ++++++++++++++++++++ modules/power/widget.go | 9 ++++++--- 3 files changed, 28 insertions(+), 4 deletions(-) create mode 100644 modules/power/settings.go diff --git a/main.go b/main.go index 93fb1510..67e60119 100644 --- a/main.go +++ b/main.go @@ -261,7 +261,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w case "pagerduty": widget = pagerduty.NewWidget(app) case "power": - widget = power.NewWidget(app) + settings := power.NewSettingsFromYAML(wtf.Config) + widget = power.NewWidget(app, settings) case "prettyweather": widget = prettyweather.NewWidget(app) case "resourceusage": diff --git a/modules/power/settings.go b/modules/power/settings.go new file mode 100644 index 00000000..8d03c2bf --- /dev/null +++ b/modules/power/settings.go @@ -0,0 +1,20 @@ +package power + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + filePath string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + return &settings +} diff --git a/modules/power/widget.go b/modules/power/widget.go index ee091df3..97891b1d 100644 --- a/modules/power/widget.go +++ b/modules/power/widget.go @@ -10,13 +10,16 @@ import ( type Widget struct { wtf.TextWidget - Battery *Battery + Battery *Battery + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "Power", "power", false), - Battery: NewBattery(), + + Battery: NewBattery(), + settings: settings, } widget.View.SetWrap(true) From a8e9f69c227ac94e2b79fe04de3de0696822c16c Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 01:39:45 -0700 Subject: [PATCH 29/60] WTF-400 PagerDuty extracted to new config format --- main.go | 3 ++- modules/pagerduty/client.go | 17 ++++------------- modules/pagerduty/settings.go | 32 ++++++++++++++++++++++++++++++++ modules/pagerduty/widget.go | 19 +++++++++++-------- 4 files changed, 49 insertions(+), 22 deletions(-) create mode 100644 modules/pagerduty/settings.go diff --git a/main.go b/main.go index 67e60119..7eb2fc04 100644 --- a/main.go +++ b/main.go @@ -259,7 +259,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := opsgenie.NewSettingsFromYAML(wtf.Config) widget = opsgenie.NewWidget(app, settings) case "pagerduty": - widget = pagerduty.NewWidget(app) + settings := pagerduty.NewSettingsFromYAML(wtf.Config) + widget = pagerduty.NewWidget(app, settings) case "power": settings := power.NewSettingsFromYAML(wtf.Config) widget = power.NewWidget(app, settings) diff --git a/modules/pagerduty/client.go b/modules/pagerduty/client.go index d8f28421..aa8766b9 100644 --- a/modules/pagerduty/client.go +++ b/modules/pagerduty/client.go @@ -1,16 +1,14 @@ package pagerduty import ( - "os" "time" "github.com/PagerDuty/go-pagerduty" - "github.com/wtfutil/wtf/wtf" ) // GetOnCalls returns a list of people currently on call -func GetOnCalls() ([]pagerduty.OnCall, error) { - client := pagerduty.NewClient(apiKey()) +func GetOnCalls(apiKey string) ([]pagerduty.OnCall, error) { + client := pagerduty.NewClient(apiKey) var results []pagerduty.OnCall @@ -38,8 +36,8 @@ func GetOnCalls() ([]pagerduty.OnCall, error) { } // GetIncidents returns a list of people currently on call -func GetIncidents() ([]pagerduty.Incident, error) { - client := pagerduty.NewClient(apiKey()) +func GetIncidents(apiKey string) ([]pagerduty.Incident, error) { + client := pagerduty.NewClient(apiKey) var results []pagerduty.Incident @@ -64,10 +62,3 @@ func GetIncidents() ([]pagerduty.Incident, error) { return results, nil } - -func apiKey() string { - return wtf.Config.UString( - "wtf.mods.pagerduty.apiKey", - os.Getenv("WTF_PAGERDUTY_API_KEY"), - ) -} diff --git a/modules/pagerduty/settings.go b/modules/pagerduty/settings.go new file mode 100644 index 00000000..0e1ab511 --- /dev/null +++ b/modules/pagerduty/settings.go @@ -0,0 +1,32 @@ +package pagerduty + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiKey string + escalationFilter []interface{} + showIncidents bool + showSchedules bool +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.pagerduty") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_PAGERDUTY_API_KEY")), + escalationFilter: localConfig.UList("escalationFilter"), + showIncidents: localConfig.UBool("showIncidents", true), + showSchedules: localConfig.UBool("showSchedules", true), + } + + return &settings +} diff --git a/modules/pagerduty/widget.go b/modules/pagerduty/widget.go index 469abbdb..d95201f8 100644 --- a/modules/pagerduty/widget.go +++ b/modules/pagerduty/widget.go @@ -11,11 +11,15 @@ import ( type Widget struct { wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "PagerDuty", "pagerduty", false), + + settings: settings, } return &widget @@ -30,12 +34,12 @@ func (widget *Widget) Refresh() { var err1 error var err2 error - if wtf.Config.UBool("wtf.mods.pagerduty.showSchedules", true) { - onCalls, err1 = GetOnCalls() + if widget.settings.showSchedules { + onCalls, err1 = GetOnCalls(widget.settings.apiKey) } - if wtf.Config.UBool("wtf.mods.pagerduty.showIncidents") { - incidents, err2 = GetIncidents() + if widget.settings.showIncidents { + incidents, err2 = GetIncidents(widget.settings.apiKey) } widget.View.SetTitle(widget.ContextualTitle(fmt.Sprintf("%s", widget.Name()))) @@ -75,15 +79,14 @@ func (widget *Widget) contentFrom(onCalls []pagerduty.OnCall, incidents []pagerd tree := make(map[string][]pagerduty.OnCall) - filtering := wtf.Config.UList("wtf.mods.pagerduty.escalationFilter") filter := make(map[string]bool) - for _, item := range filtering { + for _, item := range widget.settings.escalationFilter { filter[item.(string)] = true } for _, onCall := range onCalls { key := onCall.EscalationPolicy.Summary - if len(filtering) == 0 || filter[key] { + if len(widget.settings.escalationFilter) == 0 || filter[key] { tree[key] = append(tree[key], onCall) } } From e55cf754b3b1dd910007eedc6054f61fb3e32199 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 01:46:36 -0700 Subject: [PATCH 30/60] WTF-400 PrettyWeather extracted to new config format --- main.go | 3 +- .../weatherservices/prettyweather/settings.go | 30 +++++++++++++++++++ .../weatherservices/prettyweather/widget.go | 24 +++++++-------- 3 files changed, 44 insertions(+), 13 deletions(-) create mode 100644 modules/weatherservices/prettyweather/settings.go diff --git a/main.go b/main.go index 7eb2fc04..621e302e 100644 --- a/main.go +++ b/main.go @@ -265,7 +265,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := power.NewSettingsFromYAML(wtf.Config) widget = power.NewWidget(app, settings) case "prettyweather": - widget = prettyweather.NewWidget(app) + settings := prettyweather.NewSettingsFromYAML(wtf.Config) + widget = prettyweather.NewWidget(app, settings) case "resourceusage": widget = resourceusage.NewWidget(app) case "security": diff --git a/modules/weatherservices/prettyweather/settings.go b/modules/weatherservices/prettyweather/settings.go new file mode 100644 index 00000000..24fe08b7 --- /dev/null +++ b/modules/weatherservices/prettyweather/settings.go @@ -0,0 +1,30 @@ +package prettyweather + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + city string + unit string + view string + language string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.prettyweather") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + city: localConfig.UString("city", "Barcelona"), + language: localConfig.UString("language", "en"), + unit: localConfig.UString("unit", "m"), + view: localConfig.UString("view", "0"), + } + + return &settings +} diff --git a/modules/weatherservices/prettyweather/widget.go b/modules/weatherservices/prettyweather/widget.go index eb1963a7..6faee73d 100644 --- a/modules/weatherservices/prettyweather/widget.go +++ b/modules/weatherservices/prettyweather/widget.go @@ -11,16 +11,16 @@ import ( type Widget struct { wtf.TextWidget + result string - unit string - city string - view string - language string + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "Pretty Weather", "prettyweather", false), + + settings: settings, } return &widget @@ -35,17 +35,18 @@ func (widget *Widget) Refresh() { //this method reads the config and calls wttr.in for pretty weather func (widget *Widget) prettyWeather() { client := &http.Client{} - widget.unit = wtf.Config.UString("wtf.mods.prettyweather.unit", "m") - widget.city = wtf.Config.UString("wtf.mods.prettyweather.city", "") - widget.view = wtf.Config.UString("wtf.mods.prettyweather.view", "0") - widget.language = wtf.Config.UString("wtf.mods.prettyweather.language", "en") - req, err := http.NewRequest("GET", "https://wttr.in/"+widget.city+"?"+widget.view+"?"+widget.unit, nil) + + city := widget.settings.city + unit := widget.settings.unit + view := widget.settings.view + + req, err := http.NewRequest("GET", "https://wttr.in/"+city+"?"+view+"?"+unit, nil) if err != nil { widget.result = err.Error() return } - req.Header.Set("Accept-Language", widget.language) + req.Header.Set("Accept-Language", widget.settings.language) req.Header.Set("User-Agent", "curl") response, err := client.Do(req) if err != nil { @@ -61,6 +62,5 @@ func (widget *Widget) prettyWeather() { return } - //widget.result = strings.TrimSpace(string(contents)) widget.result = strings.TrimSpace(wtf.ASCIItoTviewColors(string(contents))) } From 8df624f2c0884725f97bbc6f271a00f19a385f14 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 01:54:39 -0700 Subject: [PATCH 31/60] WTF-400 ResourceUsage extracted to new config format --- main.go | 3 ++- modules/resourceusage/settings.go | 18 ++++++++++++++++++ modules/resourceusage/widget.go | 6 +++++- 3 files changed, 25 insertions(+), 2 deletions(-) create mode 100644 modules/resourceusage/settings.go diff --git a/main.go b/main.go index 621e302e..343b388d 100644 --- a/main.go +++ b/main.go @@ -268,7 +268,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := prettyweather.NewSettingsFromYAML(wtf.Config) widget = prettyweather.NewWidget(app, settings) case "resourceusage": - widget = resourceusage.NewWidget(app) + settings := resourceusage.NewSettingsFromYAML(wtf.Config) + widget = resourceusage.NewWidget(app, settings) case "security": widget = security.NewWidget(app) case "status": diff --git a/modules/resourceusage/settings.go b/modules/resourceusage/settings.go new file mode 100644 index 00000000..1910666d --- /dev/null +++ b/modules/resourceusage/settings.go @@ -0,0 +1,18 @@ +package resourceusage + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + return &settings +} diff --git a/modules/resourceusage/widget.go b/modules/resourceusage/widget.go index f4991c35..d1218f41 100644 --- a/modules/resourceusage/widget.go +++ b/modules/resourceusage/widget.go @@ -17,12 +17,16 @@ var ok = true // Widget define wtf widget to register widget later type Widget struct { wtf.BarGraph + + settings *Settings } // NewWidget Make new instance of widget -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ BarGraph: wtf.NewBarGraph(app, "Resource Usage", "resourceusage", false), + + settings: settings, } widget.View.SetWrap(false) From d3eef146cb286fad536710d30d791b1743deb813 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 02:04:06 -0700 Subject: [PATCH 32/60] WTF-400 Security extracted to new config format --- main.go | 7 ++++--- modules/security/settings.go | 18 ++++++++++++++++++ modules/security/widget.go | 12 +++++++----- 3 files changed, 29 insertions(+), 8 deletions(-) create mode 100644 modules/security/settings.go diff --git a/main.go b/main.go index 343b388d..9b774d3a 100644 --- a/main.go +++ b/main.go @@ -270,8 +270,11 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w case "resourceusage": settings := resourceusage.NewSettingsFromYAML(wtf.Config) widget = resourceusage.NewWidget(app, settings) + case "rollbar": + widget = rollbar.NewWidget(app, pages) case "security": - widget = security.NewWidget(app) + settings := security.NewSettingsFromYAML(wtf.Config) + widget = security.NewWidget(app, settings) case "status": widget = status.NewWidget(app) case "system": @@ -289,8 +292,6 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w widget = todoist.NewWidget(app, pages) case "travisci": widget = travisci.NewWidget(app, pages) - case "rollbar": - widget = rollbar.NewWidget(app, pages) case "trello": widget = trello.NewWidget(app) case "twitter": diff --git a/modules/security/settings.go b/modules/security/settings.go new file mode 100644 index 00000000..b8c05c90 --- /dev/null +++ b/modules/security/settings.go @@ -0,0 +1,18 @@ +package security + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + return &settings +} diff --git a/modules/security/widget.go b/modules/security/widget.go index 2bd39415..e8e5fed9 100644 --- a/modules/security/widget.go +++ b/modules/security/widget.go @@ -10,11 +10,15 @@ import ( type Widget struct { wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "Security", "security", false), + + settings: settings, } return &widget @@ -48,12 +52,10 @@ func (widget *Widget) contentFrom(data *SecurityData) string { str = str + "\n" str = str + " [red]Users[white]\n" - str = str + fmt.Sprintf(" %s", strings.Join(data.LoggedInUsers, "\n ")) - str = str + "\n" + str = str + fmt.Sprintf(" %s", strings.Join(data.LoggedInUsers, "\n ")) + str = str + "\n\n" str = str + " [red]DNS[white]\n" - //str = str + fmt.Sprintf(" %8s: [%s]%-3s[white] %-16s\n", "Enabled", widget.labelColor(data.FirewallEnabled), data.FirewallEnabled, data.DnsAt(0)) - //str = str + fmt.Sprintf(" %8s: [%s]%-3s[white] %-16s\n", "Stealth", widget.labelColor(data.FirewallStealth), data.FirewallStealth, data.DnsAt(1)) str = str + fmt.Sprintf(" %12s\n", data.DnsAt(0)) str = str + fmt.Sprintf(" %12s\n", data.DnsAt(1)) str = str + "\n" From 0403b75fe8935a0ca7ea823366b02bc45dec4f26 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 02:13:21 -0700 Subject: [PATCH 33/60] WTF-400 Rollbar extracted to new config format --- main.go | 3 ++- modules/rollbar/client.go | 3 +-- modules/rollbar/settings.go | 34 ++++++++++++++++++++++++++++++++++ modules/rollbar/widget.go | 32 ++++++++++++++++++++------------ 4 files changed, 57 insertions(+), 15 deletions(-) create mode 100644 modules/rollbar/settings.go diff --git a/main.go b/main.go index 9b774d3a..17b10f3b 100644 --- a/main.go +++ b/main.go @@ -271,7 +271,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := resourceusage.NewSettingsFromYAML(wtf.Config) widget = resourceusage.NewWidget(app, settings) case "rollbar": - widget = rollbar.NewWidget(app, pages) + settings := rollbar.NewSettingsFromYAML(wtf.Config) + widget = rollbar.NewWidget(app, pages, settings) case "security": settings := security.NewSettingsFromYAML(wtf.Config) widget = security.NewWidget(app, settings) diff --git a/modules/rollbar/client.go b/modules/rollbar/client.go index 751f79f7..431b87c8 100644 --- a/modules/rollbar/client.go +++ b/modules/rollbar/client.go @@ -12,10 +12,9 @@ import ( "github.com/wtfutil/wtf/wtf" ) -func CurrentActiveItems() (*ActiveItems, error) { +func CurrentActiveItems(accessToken string) (*ActiveItems, error) { items := &ActiveItems{} - accessToken := wtf.Config.UString("wtf.mods.rollbar.accessToken", "") rollbarAPIURL.Host = "api.rollbar.com" rollbarAPIURL.Path = "/api/1/items" resp, err := rollbarItemRequest(accessToken) diff --git a/modules/rollbar/settings.go b/modules/rollbar/settings.go new file mode 100644 index 00000000..84ddff73 --- /dev/null +++ b/modules/rollbar/settings.go @@ -0,0 +1,34 @@ +package rollbar + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + accessToken string + activeOnly bool + assignedToName string + count int + projectName string + projectOwner string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.rollbar") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + accessToken: localConfig.UString("accessToken"), + activeOnly: localConfig.UBool("activeOnly"), + assignedToName: localConfig.UString("assignedToName"), + count: localConfig.UInt("count", 10), + projectName: localConfig.UString("projectName", "Items"), + projectOwner: localConfig.UString("projectOwner"), + } + + return &settings +} diff --git a/modules/rollbar/widget.go b/modules/rollbar/widget.go index e1f34204..245081f9 100644 --- a/modules/rollbar/widget.go +++ b/modules/rollbar/widget.go @@ -29,13 +29,17 @@ type Widget struct { items *Result selected int + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Rollbar", "rollbar", true), + + settings: settings, } + widget.HelpfulWidget.SetView(widget.View) widget.unselect() @@ -51,7 +55,7 @@ func (widget *Widget) Refresh() { return } - items, err := CurrentActiveItems() + items, err := CurrentActiveItems(widget.settings.accessToken) if err != nil { widget.View.SetWrap(true) @@ -72,16 +76,14 @@ func (widget *Widget) display() { } widget.View.SetWrap(false) - projectName := wtf.Config.UString("wtf.mods.rollbar.projectName", "Items") - widget.View.SetTitle(widget.ContextualTitle(fmt.Sprintf("%s - %s", widget.Name(), projectName))) + widget.View.SetTitle(widget.ContextualTitle(fmt.Sprintf("%s - %s", widget.Name(), widget.settings.projectName))) widget.View.SetText(widget.contentFrom(widget.items)) } func (widget *Widget) contentFrom(result *Result) string { var str string - count := wtf.Config.UInt("wtf.mods.rollbar.count", 10) - if len(result.Items) > count { - result.Items = result.Items[:count] + if len(result.Items) > widget.settings.count { + result.Items = result.Items[:widget.settings.count] } for idx, item := range result.Items { @@ -151,12 +153,18 @@ func (widget *Widget) prev() { } func (widget *Widget) openBuild() { - sel := widget.selected - projectOwner := wtf.Config.UString("wtf.mods.rollbar.projectOwner", "") - projectName := wtf.Config.UString("wtf.mods.rollbar.projectName", "") - if sel >= 0 && widget.items != nil && sel < len(widget.items.Items) { + if widget.selected >= 0 && widget.items != nil && widget.selected < len(widget.items.Items) { item := &widget.items.Items[widget.selected] - wtf.OpenFile(fmt.Sprintf("https://rollbar.com/%s/%s/%s/%d", projectOwner, projectName, "items", item.ID)) + + wtf.OpenFile( + fmt.Sprintf( + "https://rollbar.com/%s/%s/%s/%d", + widget.settings.projectOwner, + widget.settings.projectName, + "items", + item.ID, + ), + ) } } From ae081e4b9fd6283f1ca3cd106a5134dd2dd9fd52 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 02:35:04 -0700 Subject: [PATCH 34/60] WTF-400 Spotify extracted to new config format --- main.go | 9 +++++---- modules/spotify/settings.go | 18 ++++++++++++++++++ modules/spotify/widget.go | 10 +++++++--- 3 files changed, 30 insertions(+), 7 deletions(-) create mode 100644 modules/spotify/settings.go diff --git a/main.go b/main.go index 17b10f3b..6a627e11 100644 --- a/main.go +++ b/main.go @@ -276,14 +276,15 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w case "security": settings := security.NewSettingsFromYAML(wtf.Config) widget = security.NewWidget(app, settings) + case "spotify": + settings := spotify.NewSettingsFromYAML(wtf.Config) + widget = spotify.NewWidget(app, pages, settings) + case "spotifyweb": + widget = spotifyweb.NewWidget(app, pages) case "status": widget = status.NewWidget(app) case "system": widget = system.NewWidget(app, date, version) - case "spotify": - widget = spotify.NewWidget(app, pages) - case "spotifyweb": - widget = spotifyweb.NewWidget(app, pages) case "textfile": widget = textfile.NewWidget(app, pages) case "todo": diff --git a/modules/spotify/settings.go b/modules/spotify/settings.go new file mode 100644 index 00000000..fe81ff57 --- /dev/null +++ b/modules/spotify/settings.go @@ -0,0 +1,18 @@ +package spotify + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + return &settings +} diff --git a/modules/spotify/widget.go b/modules/spotify/widget.go index c6b4aadb..98c4668b 100644 --- a/modules/spotify/widget.go +++ b/modules/spotify/widget.go @@ -20,17 +20,21 @@ const HelpText = ` type Widget struct { wtf.HelpfulWidget wtf.TextWidget - spotigopher.SpotifyClient + + settings *Settings spotigopher.Info + spotigopher.SpotifyClient } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { spotifyClient := spotigopher.NewClient() widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Spotify", "spotify", true), - SpotifyClient: spotifyClient, + Info: spotigopher.Info{}, + SpotifyClient: spotifyClient, + settings: settings, } widget.HelpfulWidget.SetView(widget.View) widget.TextWidget.RefreshInt = 5 From b4868a54e6ced351dbb47183f87a1209de0e4b4d Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 02:54:10 -0700 Subject: [PATCH 35/60] WTF-400 SpotifyWeb extracted to new config format --- main.go | 3 ++- modules/spotifyweb/settings.go | 30 ++++++++++++++++++++++++++++ modules/spotifyweb/widget.go | 36 ++++++++++++---------------------- 3 files changed, 44 insertions(+), 25 deletions(-) create mode 100644 modules/spotifyweb/settings.go diff --git a/main.go b/main.go index 6a627e11..0789a372 100644 --- a/main.go +++ b/main.go @@ -280,7 +280,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := spotify.NewSettingsFromYAML(wtf.Config) widget = spotify.NewWidget(app, pages, settings) case "spotifyweb": - widget = spotifyweb.NewWidget(app, pages) + settings := spotifyweb.NewSettingsFromYAML(wtf.Config) + widget = spotifyweb.NewWidget(app, pages, settings) case "status": widget = status.NewWidget(app) case "system": diff --git a/modules/spotifyweb/settings.go b/modules/spotifyweb/settings.go new file mode 100644 index 00000000..ffe6421d --- /dev/null +++ b/modules/spotifyweb/settings.go @@ -0,0 +1,30 @@ +package spotifyweb + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + callbackPort string + clientID string + secretKey string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.spotifyweb") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + callbackPort: localConfig.UString("callbackPort", "8080"), + clientID: localConfig.UString("clientID", os.Getenv("SPOTIFY_ID")), + secretKey: localConfig.UString("secretKey", os.Getenv("SPOTIFY_SECRET")), + } + + return &settings +} diff --git a/modules/spotifyweb/widget.go b/modules/spotifyweb/widget.go index 02723ffc..98af1863 100644 --- a/modules/spotifyweb/widget.go +++ b/modules/spotifyweb/widget.go @@ -4,7 +4,6 @@ import ( "errors" "fmt" "net/http" - "os" "time" "github.com/gdamore/tcell" @@ -47,10 +46,12 @@ type Info struct { type Widget struct { wtf.HelpfulWidget wtf.TextWidget + Info - clientChan chan *spotify.Client client *spotify.Client + clientChan chan *spotify.Client playerState *spotify.PlayerState + settings *Settings } var ( @@ -79,27 +80,12 @@ func authHandler(w http.ResponseWriter, r *http.Request) { tempClientChan <- &client } -func clientID() string { - return wtf.Config.UString( - "wtf.mods.spotifyweb.clientID", - os.Getenv("SPOTIFY_ID"), - ) -} - -func secretKey() string { - return wtf.Config.UString( - "wtf.mods.spotifyweb.secretKey", - os.Getenv("SPOTIFY_SECRET"), - ) -} - // NewWidget creates a new widget for WTF -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { - callbackPort = wtf.Config.UString("wtf.mods.spotifyweb.callbackPort", "8080") - redirectURI = "http://localhost:" + callbackPort + "/callback" +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { + redirectURI = "http://localhost:" + settings.callbackPort + "/callback" auth = spotify.NewAuthenticator(redirectURI, spotify.ScopeUserReadCurrentlyPlaying, spotify.ScopeUserReadPlaybackState, spotify.ScopeUserModifyPlaybackState) - auth.SetAuthInfo(clientID(), secretKey()) + auth.SetAuthInfo(settings.clientID, settings.secretKey) authURL = auth.AuthURL(state) var client *spotify.Client @@ -108,10 +94,12 @@ func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "SpotifyWeb", "spotifyweb", true), - Info: Info{}, - clientChan: tempClientChan, - client: client, - playerState: playerState, + + Info: Info{}, + client: client, + clientChan: tempClientChan, + playerState: playerState, + settings: settings, } http.HandleFunc("/callback", authHandler) From 5f07cb6db4d1bad9148884abc5dd0a3a64dac459 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 02:55:59 -0700 Subject: [PATCH 36/60] WTF-400 Status extracted to new config format --- main.go | 3 ++- modules/status/settings.go | 18 ++++++++++++++++++ modules/status/widget.go | 7 +++++-- 3 files changed, 25 insertions(+), 3 deletions(-) create mode 100644 modules/status/settings.go diff --git a/main.go b/main.go index 0789a372..8d5c39dd 100644 --- a/main.go +++ b/main.go @@ -283,7 +283,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := spotifyweb.NewSettingsFromYAML(wtf.Config) widget = spotifyweb.NewWidget(app, pages, settings) case "status": - widget = status.NewWidget(app) + settings := status.NewSettingsFromYAML(wtf.Config) + widget = status.NewWidget(app, settings) case "system": widget = system.NewWidget(app, date, version) case "textfile": diff --git a/modules/status/settings.go b/modules/status/settings.go new file mode 100644 index 00000000..b320f12b --- /dev/null +++ b/modules/status/settings.go @@ -0,0 +1,18 @@ +package status + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + return &settings +} diff --git a/modules/status/widget.go b/modules/status/widget.go index 9af4c26b..81f256d2 100644 --- a/modules/status/widget.go +++ b/modules/status/widget.go @@ -9,12 +9,15 @@ type Widget struct { wtf.TextWidget CurrentIcon int + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Status", "status", false), + TextWidget: wtf.NewTextWidget(app, "Status", "status", false), + CurrentIcon: 0, + settings: settings, } return &widget From ea88f5eece71582b8cc59398f860feaa68abc818 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 09:09:42 -0700 Subject: [PATCH 37/60] WTF-400 System extracted to new config format --- main.go | 3 ++- modules/system/settings.go | 18 ++++++++++++++++++ modules/system/widget.go | 10 ++++++---- 3 files changed, 26 insertions(+), 5 deletions(-) create mode 100644 modules/system/settings.go diff --git a/main.go b/main.go index 8d5c39dd..69e17ea9 100644 --- a/main.go +++ b/main.go @@ -286,7 +286,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := status.NewSettingsFromYAML(wtf.Config) widget = status.NewWidget(app, settings) case "system": - widget = system.NewWidget(app, date, version) + settings := system.NewSettingsFromYAML(wtf.Config) + widget = system.NewWidget(app, date, version, settings) case "textfile": widget = textfile.NewWidget(app, pages) case "todo": diff --git a/modules/system/settings.go b/modules/system/settings.go new file mode 100644 index 00000000..67662fea --- /dev/null +++ b/modules/system/settings.go @@ -0,0 +1,18 @@ +package system + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + return &settings +} diff --git a/modules/system/widget.go b/modules/system/widget.go index 063930f7..e5bb08a4 100644 --- a/modules/system/widget.go +++ b/modules/system/widget.go @@ -11,17 +11,19 @@ import ( type Widget struct { wtf.TextWidget - systemInfo *SystemInfo Date string Version string + settings *Settings + systemInfo *SystemInfo } -func NewWidget(app *tview.Application, date, version string) *Widget { +func NewWidget(app *tview.Application, date, version string, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "System", "system", false), - Date: date, - Version: version, + Date: date, + settings: settings, + Version: version, } widget.systemInfo = NewSystemInfo() From c489f2a4f4783e6f1340041a56b5ff976023a68d Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 09:30:32 -0700 Subject: [PATCH 38/60] WTF-400 Textfile extracted to new config format --- main.go | 3 ++- modules/textfile/settings.go | 28 ++++++++++++++++++++++++++++ modules/textfile/widget.go | 12 +++++++----- 3 files changed, 37 insertions(+), 6 deletions(-) create mode 100644 modules/textfile/settings.go diff --git a/main.go b/main.go index 69e17ea9..870113d2 100644 --- a/main.go +++ b/main.go @@ -289,7 +289,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := system.NewSettingsFromYAML(wtf.Config) widget = system.NewWidget(app, date, version, settings) case "textfile": - widget = textfile.NewWidget(app, pages) + settings := textfile.NewSettingsFromYAML(wtf.Config) + widget = textfile.NewWidget(app, pages, settings) case "todo": cfg := todo.NewSettingsFromYAML(wtf.Config) widget = todo.NewWidget(app, pages, cfg) diff --git a/modules/textfile/settings.go b/modules/textfile/settings.go new file mode 100644 index 00000000..b0681aa1 --- /dev/null +++ b/modules/textfile/settings.go @@ -0,0 +1,28 @@ +package textfile + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + filePaths []interface{} + format bool + formatStyle string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.textfile") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + filePaths: localConfig.UList("filePaths"), + format: localConfig.UBool("format", false), + formatStyle: localConfig.UString("formatStyle", "vim"), + } + + return &settings +} diff --git a/modules/textfile/widget.go b/modules/textfile/widget.go index 6125681b..8ead3508 100644 --- a/modules/textfile/widget.go +++ b/modules/textfile/widget.go @@ -34,13 +34,17 @@ type Widget struct { wtf.HelpfulWidget wtf.MultiSourceWidget wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), MultiSourceWidget: wtf.NewMultiSourceWidget("textfile", "filePath", "filePaths"), TextWidget: wtf.NewTextWidget(app, "TextFile", "textfile", true), + + settings: settings, } // Don't use a timer for this widget, watch for filesystem changes instead @@ -76,16 +80,14 @@ func (widget *Widget) display() { text := wtf.SigilStr(len(widget.Sources), widget.Idx, widget.View) + "\n" - if wtf.Config.UBool("wtf.mods.textfile.format", false) { + if widget.settings.format { text = text + widget.formattedText() } else { text = text + widget.plainText() } - //widget.View.Lock() widget.View.SetTitle(title) // <- Writes to TextView's title widget.View.SetText(text) // <- Writes to TextView's text - //widget.View.Unlock() } func (widget *Widget) fileName() string { @@ -105,7 +107,7 @@ func (widget *Widget) formattedText() string { lexer = lexers.Fallback } - style := styles.Get(wtf.Config.UString("wtf.mods.textfile.formatStyle", "vim")) + style := styles.Get(widget.settings.formatStyle) if style == nil { style = styles.Fallback } From 8b2fc71f92eea87176a313fd333cbe8439212ec9 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 10:01:55 -0700 Subject: [PATCH 39/60] WTF-400 Todoist extracted to new config format --- main.go | 7 ++++--- modules/todoist/display.go | 1 - modules/todoist/settings.go | 28 ++++++++++++++++++++++++++++ modules/todoist/widget.go | 22 ++++++++++------------ 4 files changed, 42 insertions(+), 16 deletions(-) create mode 100644 modules/todoist/settings.go diff --git a/main.go b/main.go index 870113d2..34886935 100644 --- a/main.go +++ b/main.go @@ -292,10 +292,11 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := textfile.NewSettingsFromYAML(wtf.Config) widget = textfile.NewWidget(app, pages, settings) case "todo": - cfg := todo.NewSettingsFromYAML(wtf.Config) - widget = todo.NewWidget(app, pages, cfg) + settings := todo.NewSettingsFromYAML(wtf.Config) + widget = todo.NewWidget(app, pages, settings) case "todoist": - widget = todoist.NewWidget(app, pages) + settings := todoist.NewSettingsFromYAML(wtf.Config) + widget = todoist.NewWidget(app, pages, settings) case "travisci": widget = travisci.NewWidget(app, pages) case "trello": diff --git a/modules/todoist/display.go b/modules/todoist/display.go index 0352b6e6..c9071419 100644 --- a/modules/todoist/display.go +++ b/modules/todoist/display.go @@ -46,6 +46,5 @@ func (widget *Widget) display() { str = str + row + wtf.PadRow((checkWidth+len(item.Content)), (checkWidth+maxLen+1)) + "\n" } - //widget.View.Clear() widget.View.SetText(str) } diff --git a/modules/todoist/settings.go b/modules/todoist/settings.go new file mode 100644 index 00000000..912d13cc --- /dev/null +++ b/modules/todoist/settings.go @@ -0,0 +1,28 @@ +package todoist + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiKey string + projects []interface{} +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.todoist") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_TODOIST_TOKEN")), + projects: localConfig.UList("projects"), + } + + return &settings +} diff --git a/modules/todoist/widget.go b/modules/todoist/widget.go index e59d4751..5d037695 100644 --- a/modules/todoist/widget.go +++ b/modules/todoist/widget.go @@ -1,8 +1,6 @@ package todoist import ( - "os" - "github.com/darkSasori/todoist" "github.com/gdamore/tcell" "github.com/rivo/tview" @@ -31,18 +29,21 @@ type Widget struct { wtf.HelpfulWidget wtf.TextWidget - projects []*Project idx int + projects []*Project + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "Todoist", "todoist", true), + + settings: settings, } widget.loadAPICredentials() - widget.projects = loadProjects() + widget.loadProjects() widget.HelpfulWidget.SetView(widget.View) widget.View.SetInputCapture(widget.keyboardIntercept) @@ -169,21 +170,18 @@ func (w *Widget) keyboardIntercept(event *tcell.EventKey) *tcell.EventKey { } func (widget *Widget) loadAPICredentials() { - todoist.Token = wtf.Config.UString( - "wtf.mods.todoist.apiKey", - os.Getenv("WTF_TODOIST_TOKEN"), - ) + todoist.Token = widget.settings.apiKey } -func loadProjects() []*Project { +func (widget *Widget) loadProjects() { projects := []*Project{} - for _, id := range wtf.Config.UList("wtf.mods.todoist.projects") { + for _, id := range widget.settings.projects { proj := NewProject(id.(int)) projects = append(projects, proj) } - return projects + widget.projects = projects } func (w *Widget) vimBindings(event *tcell.EventKey) tcell.Key { From daa422aee40505d729903189141d3551ac2baff3 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 10:32:39 -0700 Subject: [PATCH 40/60] WTF-400 Minor code cleanup --- cfg/config_files.go | 1 - logger/settings.go | 2 -- modules/gerrit/widget.go | 1 - 3 files changed, 4 deletions(-) diff --git a/cfg/config_files.go b/cfg/config_files.go index 284dbae8..852ecf25 100644 --- a/cfg/config_files.go +++ b/cfg/config_files.go @@ -6,7 +6,6 @@ import ( "os" "github.com/olebedev/config" - // "github.com/wtfutil/wtf/logger" "github.com/wtfutil/wtf/wtf" ) diff --git a/logger/settings.go b/logger/settings.go index f5787b98..e880879a 100644 --- a/logger/settings.go +++ b/logger/settings.go @@ -7,8 +7,6 @@ import ( type Settings struct { common *cfg.Common - - filePath string } func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { diff --git a/modules/gerrit/widget.go b/modules/gerrit/widget.go index f7185aaf..fa1ecb86 100644 --- a/modules/gerrit/widget.go +++ b/modules/gerrit/widget.go @@ -4,7 +4,6 @@ import ( "crypto/tls" "fmt" "net/http" - // "os" "regexp" glb "github.com/andygrunwald/go-gerrit" From 5593f19e1cee829d5514d65eadad9e0107f09be5 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 17:09:08 -0700 Subject: [PATCH 41/60] WTF-400 TravisCI extracted to new config format --- main.go | 3 ++- modules/circleci/settings.go | 4 ++-- modules/circleci/widget.go | 2 +- modules/travisci/client.go | 19 ++++--------------- modules/travisci/settings.go | 28 ++++++++++++++++++++++++++++ modules/travisci/widget.go | 7 +++++-- 6 files changed, 42 insertions(+), 21 deletions(-) create mode 100644 modules/travisci/settings.go diff --git a/main.go b/main.go index 34886935..f55be2d7 100644 --- a/main.go +++ b/main.go @@ -298,7 +298,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := todoist.NewSettingsFromYAML(wtf.Config) widget = todoist.NewWidget(app, pages, settings) case "travisci": - widget = travisci.NewWidget(app, pages) + settings := travisci.NewSettingsFromYAML(wtf.Config) + widget = travisci.NewWidget(app, pages, settings) case "trello": widget = trello.NewWidget(app) case "twitter": diff --git a/modules/circleci/settings.go b/modules/circleci/settings.go index b9cb9849..2dcdffa9 100644 --- a/modules/circleci/settings.go +++ b/modules/circleci/settings.go @@ -10,7 +10,7 @@ import ( type Settings struct { Common *cfg.Common - APIKey string + apiKey string } func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { @@ -18,7 +18,7 @@ func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { settings := Settings{ Common: cfg.NewCommonSettingsFromYAML(ymlConfig), - APIKey: localConfig.UString("apiKey", os.Getenv("WTF_CIRCLE_API_KEY")), + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_CIRCLE_API_KEY")), } return &settings diff --git a/modules/circleci/widget.go b/modules/circleci/widget.go index ce8ecf62..63faf855 100644 --- a/modules/circleci/widget.go +++ b/modules/circleci/widget.go @@ -17,7 +17,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "CircleCI", "circleci", false), - Client: NewClient(settings.APIKey), + Client: NewClient(settings.apiKey), settings: settings, } diff --git a/modules/travisci/client.go b/modules/travisci/client.go index a37a0d7b..0434fcfd 100644 --- a/modules/travisci/client.go +++ b/modules/travisci/client.go @@ -8,9 +8,6 @@ import ( "io/ioutil" "net/http" "net/url" - "os" - - "github.com/wtfutil/wtf/wtf" ) var TRAVIS_HOSTS = map[bool]string{ @@ -18,13 +15,12 @@ var TRAVIS_HOSTS = map[bool]string{ true: "travis-ci.com", } -func BuildsFor() (*Builds, error) { +func BuildsFor(apiKey string, pro bool) (*Builds, error) { builds := &Builds{} - pro := wtf.Config.UBool("wtf.mods.travisci.pro", false) travisAPIURL.Host = "api." + TRAVIS_HOSTS[pro] - resp, err := travisRequest("builds") + resp, err := travisRequest(apiKey, "builds") if err != nil { return builds, err } @@ -40,7 +36,7 @@ var ( travisAPIURL = &url.URL{Scheme: "https", Path: "/"} ) -func travisRequest(path string) (*http.Response, error) { +func travisRequest(apiKey string, path string) (*http.Response, error) { params := url.Values{} params.Add("limit", "10") @@ -51,7 +47,7 @@ func travisRequest(path string) (*http.Response, error) { req.Header.Add("Content-Type", "application/json") req.Header.Add("Travis-API-Version", "3") - bearer := fmt.Sprintf("token %s", apiToken()) + bearer := fmt.Sprintf("token %s", apiKey) req.Header.Add("Authorization", bearer) if err != nil { return nil, err @@ -70,13 +66,6 @@ func travisRequest(path string) (*http.Response, error) { return resp, nil } -func apiToken() string { - return wtf.Config.UString( - "wtf.mods.travisci.apiKey", - os.Getenv("WTF_TRAVIS_API_TOKEN"), - ) -} - func parseJson(obj interface{}, text io.Reader) { jsonStream, err := ioutil.ReadAll(text) if err != nil { diff --git a/modules/travisci/settings.go b/modules/travisci/settings.go new file mode 100644 index 00000000..dd16d7b5 --- /dev/null +++ b/modules/travisci/settings.go @@ -0,0 +1,28 @@ +package travisci + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + Common *cfg.Common + + apiKey string + pro bool +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.travisci") + + settings := Settings{ + Common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_TRAVIS_API_TOKEN")), + pro: localConfig.UBool("pro", false), + } + + return &settings +} diff --git a/modules/travisci/widget.go b/modules/travisci/widget.go index 8844fcaf..e6f21346 100644 --- a/modules/travisci/widget.go +++ b/modules/travisci/widget.go @@ -28,12 +28,15 @@ type Widget struct { builds *Builds selected int + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "TravisCI", "travisci", true), + + settings: settings, } widget.HelpfulWidget.SetView(widget.View) @@ -51,7 +54,7 @@ func (widget *Widget) Refresh() { return } - builds, err := BuildsFor() + builds, err := BuildsFor(widget.settings.apiKey, widget.settings.pro) if err != nil { widget.View.SetWrap(true) From 4b5045a0bb953756e74c61cbbb34ba4305164ef4 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 20:22:54 -0700 Subject: [PATCH 42/60] WTF-400 Trello extracted to new config format --- main.go | 3 +- modules/trello/client.go | 13 ++++----- modules/trello/settings.go | 56 ++++++++++++++++++++++++++++++++++++++ modules/trello/widget.go | 53 ++++++++++-------------------------- 4 files changed, 78 insertions(+), 47 deletions(-) create mode 100644 modules/trello/settings.go diff --git a/main.go b/main.go index f55be2d7..c7a59392 100644 --- a/main.go +++ b/main.go @@ -301,7 +301,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := travisci.NewSettingsFromYAML(wtf.Config) widget = travisci.NewWidget(app, pages, settings) case "trello": - widget = trello.NewWidget(app) + settings := trello.NewSettingsFromYAML(wtf.Config) + widget = trello.NewWidget(app, settings) case "twitter": widget = twitter.NewWidget(app, pages) case "victorops": diff --git a/modules/trello/client.go b/modules/trello/client.go index 3252eb57..f61f9968 100644 --- a/modules/trello/client.go +++ b/modules/trello/client.go @@ -4,11 +4,10 @@ import ( "fmt" "github.com/adlio/trello" - "github.com/wtfutil/wtf/wtf" ) -func GetCards(client *trello.Client, lists map[string]string) (*SearchResult, error) { - boardID, err := getBoardID(client) +func GetCards(client *trello.Client, username string, boardName string, lists map[string]string) (*SearchResult, error) { + boardID, err := getBoardID(client, username, boardName) if err != nil { return nil, err } @@ -43,8 +42,8 @@ func GetCards(client *trello.Client, lists map[string]string) (*SearchResult, er return searchResult, nil } -func getBoardID(client *trello.Client) (string, error) { - member, err := client.GetMember(wtf.Config.UString("wtf.mods.trello.username"), trello.Defaults()) +func getBoardID(client *trello.Client, username, boardName string) (string, error) { + member, err := client.GetMember(username, trello.Defaults()) if err != nil { return "", err } @@ -55,12 +54,12 @@ func getBoardID(client *trello.Client) (string, error) { } for _, board := range boards { - if board.Name == wtf.Config.UString("wtf.mods.trello.board") { + if board.Name == boardName { return board.ID, nil } } - return "", fmt.Errorf("could not find board with name %s", wtf.Config.UString("wtf.mods.trello.board")) + return "", fmt.Errorf("could not find board with name %s", boardName) } func getListIDs(client *trello.Client, boardID string, lists map[string]string) (map[string]string, error) { diff --git a/modules/trello/settings.go b/modules/trello/settings.go new file mode 100644 index 00000000..c02bcf5d --- /dev/null +++ b/modules/trello/settings.go @@ -0,0 +1,56 @@ +package trello + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + accessToken string + apiKey string + board string + list map[string]string + username string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.trello") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + accessToken: localConfig.UString("accessToken", os.Getenv("WTF_TRELLO_ACCESS_TOKEN")), + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_TRELLO_APP_KEY")), + board: localConfig.UString("board"), + username: localConfig.UString("username"), + } + + settings.list = mapifyList(localConfig) + + return &settings +} + +func mapifyList(localConfig *config.Config) map[string]string { + lists := make(map[string]string) + + // Single list + list, err := localConfig.String("list") + if err == nil { + lists[list] = "" + return lists + } + + // Array of lists + listList := localConfig.UList("project") + for _, listName := range listList { + if list, ok := listName.(string); ok { + lists[list] = "" + } + } + + return lists +} diff --git a/modules/trello/widget.go b/modules/trello/widget.go index 61ddf0cc..8ba8c89e 100644 --- a/modules/trello/widget.go +++ b/modules/trello/widget.go @@ -2,7 +2,6 @@ package trello import ( "fmt" - "os" "github.com/adlio/trello" "github.com/rivo/tview" @@ -11,11 +10,15 @@ import ( type Widget struct { wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "Trello", "trello", false), + + settings: settings, } return &widget @@ -25,12 +28,17 @@ func NewWidget(app *tview.Application) *Widget { func (widget *Widget) Refresh() { client := trello.NewClient( - widget.apiKey(), - widget.accessToken(), + widget.settings.apiKey, + widget.settings.accessToken, ) // Get the cards - searchResult, err := GetCards(client, getLists()) + searchResult, err := GetCards( + client, + widget.settings.username, + widget.settings.board, + widget.settings.list, + ) var content string if err != nil { @@ -43,7 +51,7 @@ func (widget *Widget) Refresh() { fmt.Sprintf( "[white]%s: [green]%s ", widget.Name(), - wtf.Config.UString("wtf.mods.trello.board"), + widget.settings.board, ), ) content = widget.contentFrom(searchResult) @@ -54,20 +62,6 @@ func (widget *Widget) Refresh() { /* -------------------- Unexported Functions -------------------- */ -func (widget *Widget) accessToken() string { - return wtf.Config.UString( - "wtf.mods.trello.accessToken", - os.Getenv("WTF_TRELLO_ACCESS_TOKEN"), - ) -} - -func (widget *Widget) apiKey() string { - return wtf.Config.UString( - "wtf.mods.trello.apiKey", - os.Getenv("WTF_TRELLO_APP_KEY"), - ) -} - func (widget *Widget) contentFrom(searchResult *SearchResult) string { str := "" @@ -81,22 +75,3 @@ func (widget *Widget) contentFrom(searchResult *SearchResult) string { return str } - -func getLists() map[string]string { - list := make(map[string]string) - // see if project is set to a single string - configPath := "wtf.mods.trello.list" - singleList, err := wtf.Config.String(configPath) - if err == nil { - list[singleList] = "" - return list - } - // else, assume list - multiList := wtf.Config.UList(configPath) - for _, proj := range multiList { - if str, ok := proj.(string); ok { - list[str] = "" - } - } - return list -} From eaa8825aa56663835b2788e18b29fa04efd081e0 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 20:33:03 -0700 Subject: [PATCH 43/60] WTF-400 Twitter extracted to new config format --- main.go | 3 ++- modules/twitter/client.go | 21 +++++---------------- modules/twitter/request.go | 3 +-- modules/twitter/settings.go | 30 ++++++++++++++++++++++++++++++ modules/twitter/widget.go | 16 ++++++++-------- 5 files changed, 46 insertions(+), 27 deletions(-) create mode 100644 modules/twitter/settings.go diff --git a/main.go b/main.go index c7a59392..467d15a3 100644 --- a/main.go +++ b/main.go @@ -304,7 +304,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := trello.NewSettingsFromYAML(wtf.Config) widget = trello.NewWidget(app, settings) case "twitter": - widget = twitter.NewWidget(app, pages) + settings := twitter.NewSettingsFromYAML(wtf.Config) + widget = twitter.NewWidget(app, pages, settings) case "victorops": widget = victorops.NewWidget(app) case "weather": diff --git a/modules/twitter/client.go b/modules/twitter/client.go index e03a6a9c..affe0a20 100644 --- a/modules/twitter/client.go +++ b/modules/twitter/client.go @@ -3,10 +3,7 @@ package twitter import ( "encoding/json" "fmt" - "os" "strconv" - - "github.com/wtfutil/wtf/wtf" ) /* NOTE: Currently single application ONLY @@ -22,15 +19,14 @@ type Client struct { } // NewClient creates and returns a new Twitter client -func NewClient() *Client { +func NewClient(settings *Settings) *Client { client := Client{ - apiBase: "https://api.twitter.com/1.1/", - count: wtf.Config.UInt("wtf.mods.twitter.count", 5), - screenName: "", + apiBase: "https://api.twitter.com/1.1/", + count: settings.count, + screenName: "", + bearerToken: settings.bearerToken, } - client.loadAPICredentials() - return &client } @@ -65,10 +61,3 @@ func (client *Client) tweets() (tweets []Tweet, err error) { return } - -func (client *Client) loadAPICredentials() { - client.bearerToken = wtf.Config.UString( - "wtf.mods.twitter.bearerToken", - os.Getenv("WTF_TWITTER_BEARER_TOKEN"), - ) -} diff --git a/modules/twitter/request.go b/modules/twitter/request.go index ec5406d3..e20a306c 100644 --- a/modules/twitter/request.go +++ b/modules/twitter/request.go @@ -13,8 +13,7 @@ func Request(bearerToken string, apiURL string) ([]byte, error) { } // Expected authorization format for single-application twitter dev accounts - req.Header.Add("Authorization", - fmt.Sprintf("Bearer %s", bearerToken)) + req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", bearerToken)) client := &http.Client{} resp, err := client.Do(req) diff --git a/modules/twitter/settings.go b/modules/twitter/settings.go new file mode 100644 index 00000000..7b139d6e --- /dev/null +++ b/modules/twitter/settings.go @@ -0,0 +1,30 @@ +package twitter + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + bearerToken string + count int + screenNames []interface{} +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.twitter") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + bearerToken: localConfig.UString("bearerToken", os.Getenv("WTF_TWITTER_BEARER_TOKEN")), + count: localConfig.UInt("count", 5), + screenNames: localConfig.UList("screenName"), + } + + return &settings +} diff --git a/modules/twitter/widget.go b/modules/twitter/widget.go index afdefa7e..f7dad81f 100644 --- a/modules/twitter/widget.go +++ b/modules/twitter/widget.go @@ -27,18 +27,20 @@ type Widget struct { wtf.MultiSourceWidget wtf.TextWidget - client *Client - idx int - sources []string + client *Client + idx int + settings *Settings + sources []string } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), MultiSourceWidget: wtf.NewMultiSourceWidget("twitter", "screenName", "screenNames"), TextWidget: wtf.NewTextWidget(app, "Twitter", "twitter", true), - idx: 0, + idx: 0, + settings: settings, } widget.HelpfulWidget.SetView(widget.View) @@ -46,7 +48,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { widget.LoadSources() widget.SetDisplayFunction(widget.display) - widget.client = NewClient() + widget.client = NewClient(settings) widget.View.SetBorderPadding(1, 1, 1, 1) widget.View.SetWrap(true) @@ -163,6 +165,4 @@ func (widget *Widget) keyboardIntercept(event *tcell.EventKey) *tcell.EventKey { default: return event } - - return event } From d0faa3cb4021a235f61c03626133b0cdcdc04fb9 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 20:40:44 -0700 Subject: [PATCH 44/60] WTF-400 VictorOps extracted to new config format --- main.go | 3 ++- modules/victorops/client.go | 20 +++----------------- modules/victorops/settings.go | 30 ++++++++++++++++++++++++++++++ modules/victorops/widget.go | 12 +++++++----- 4 files changed, 42 insertions(+), 23 deletions(-) create mode 100644 modules/victorops/settings.go diff --git a/main.go b/main.go index 467d15a3..eb18f89c 100644 --- a/main.go +++ b/main.go @@ -307,7 +307,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := twitter.NewSettingsFromYAML(wtf.Config) widget = twitter.NewWidget(app, pages, settings) case "victorops": - widget = victorops.NewWidget(app) + settings := victorops.NewSettingsFromYAML(wtf.Config) + widget = victorops.NewWidget(app, settings) case "weather": widget = weather.NewWidget(app, pages) case "zendesk": diff --git a/modules/victorops/client.go b/modules/victorops/client.go index 8c952e28..06069313 100644 --- a/modules/victorops/client.go +++ b/modules/victorops/client.go @@ -4,34 +4,20 @@ import ( "encoding/json" "fmt" "net/http" - "os" "strings" "github.com/wtfutil/wtf/logger" - "github.com/wtfutil/wtf/wtf" ) // Fetch gets the current oncall users -func Fetch() ([]OnCallTeam, error) { +func Fetch(apiID, apiKey string) ([]OnCallTeam, error) { scheduleURL := "https://api.victorops.com/api-public/v1/oncall/current" - response, err := victorOpsRequest(scheduleURL, apiID(), apiKey()) + response, err := victorOpsRequest(scheduleURL, apiID, apiKey) + return response, err } /* ---------------- Unexported Functions ---------------- */ -func apiID() string { - return wtf.Config.UString( - "wtf.mods.victorops.apiID", - os.Getenv("WTF_VICTOROPS_API_ID"), - ) -} - -func apiKey() string { - return wtf.Config.UString( - "wtf.mods.victorops.apiKey", - os.Getenv("WTF_VICTOROPS_API_KEY"), - ) -} func victorOpsRequest(url string, apiID string, apiKey string) ([]OnCallTeam, error) { req, err := http.NewRequest("GET", url, nil) diff --git a/modules/victorops/settings.go b/modules/victorops/settings.go new file mode 100644 index 00000000..ba4c106c --- /dev/null +++ b/modules/victorops/settings.go @@ -0,0 +1,30 @@ +package victorops + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiID string + apiKey string + team string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.victorops") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiID: localConfig.UString("apiID", os.Getenv("WTF_VICTOROPS_API_ID")), + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_VICTOROPS_API_KEY")), + team: localConfig.UString("team"), + } + + return &settings +} diff --git a/modules/victorops/widget.go b/modules/victorops/widget.go index a4de256f..24a49a52 100644 --- a/modules/victorops/widget.go +++ b/modules/victorops/widget.go @@ -19,11 +19,13 @@ const HelpText = ` // Widget contains text info type Widget struct { wtf.TextWidget - teams []OnCallTeam + + teams []OnCallTeam + settings *Settings } // NewWidget creates a new widget -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "VictorOps - OnCall", "victorops", true), } @@ -40,7 +42,7 @@ func (widget *Widget) Refresh() { return } - teams, err := Fetch() + teams, err := Fetch(widget.settings.apiID, widget.settings.apiKey) widget.View.SetTitle(widget.ContextualTitle(widget.Name())) if err != nil { @@ -64,10 +66,10 @@ func (widget *Widget) display() { } func (widget *Widget) contentFrom(teams []OnCallTeam) string { - teamToDisplay := wtf.Config.UString("wtf.mods.victorops.team") var str string + for _, team := range teams { - if len(teamToDisplay) > 0 && teamToDisplay != team.Slug { + if len(widget.settings.team) > 0 && widget.settings.team != team.Slug { continue } From cfdfb044dae225dc7ecb7bd9f0b87febc2fb4266 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 21:10:58 -0700 Subject: [PATCH 45/60] WTF-400 Weather extracted to new config format --- main.go | 3 +- modules/weatherservices/weather/display.go | 11 ++-- modules/weatherservices/weather/settings.go | 39 ++++++++++++++ modules/weatherservices/weather/widget.go | 56 +++++++-------------- 4 files changed, 63 insertions(+), 46 deletions(-) create mode 100644 modules/weatherservices/weather/settings.go diff --git a/main.go b/main.go index eb18f89c..2ac8b77b 100644 --- a/main.go +++ b/main.go @@ -310,7 +310,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := victorops.NewSettingsFromYAML(wtf.Config) widget = victorops.NewWidget(app, settings) case "weather": - widget = weather.NewWidget(app, pages) + settings := weather.NewSettingsFromYAML(wtf.Config) + widget = weather.NewWidget(app, pages, settings) case "zendesk": widget = zendesk.NewWidget(app) default: diff --git a/modules/weatherservices/weather/display.go b/modules/weatherservices/weather/display.go index 12b6119d..929e4b57 100644 --- a/modules/weatherservices/weather/display.go +++ b/modules/weatherservices/weather/display.go @@ -9,7 +9,6 @@ import ( ) func (widget *Widget) display() { - if widget.apiKeyValid() == false { widget.View.SetText(" Environment variable WTF_OWM_API_KEY is not set") return @@ -54,19 +53,17 @@ func (widget *Widget) sunInfo(cityData *owm.CurrentWeatherData) string { } func (widget *Widget) temperatures(cityData *owm.CurrentWeatherData) string { - tempUnit := wtf.Config.UString("wtf.mods.weather.tempUnit", "C") - - str := fmt.Sprintf("%8s: %4.1f° %s\n", "High", cityData.Main.TempMax, tempUnit) + str := fmt.Sprintf("%8s: %4.1f° %s\n", "High", cityData.Main.TempMax, widget.settings.tempUnit) str = str + fmt.Sprintf( "%8s: [%s]%4.1f° %s[white]\n", "Current", - wtf.Config.UString("wtf.mods.weather.colors.current", "green"), + widget.settings.colors.current, cityData.Main.Temp, - tempUnit, + widget.settings.tempUnit, ) - str = str + fmt.Sprintf("%8s: %4.1f° %s\n", "Low", cityData.Main.TempMin, tempUnit) + str = str + fmt.Sprintf("%8s: %4.1f° %s\n", "Low", cityData.Main.TempMin, widget.settings.tempUnit) return str } diff --git a/modules/weatherservices/weather/settings.go b/modules/weatherservices/weather/settings.go new file mode 100644 index 00000000..1f52db16 --- /dev/null +++ b/modules/weatherservices/weather/settings.go @@ -0,0 +1,39 @@ +package weather + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type colors struct { + current string +} + +type Settings struct { + colors + common *cfg.Common + + apiKey string + cityIDs []interface{} + language string + tempUnit string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.weather") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_OWM_API_KEY")), + cityIDs: localConfig.UList("cityids"), + language: localConfig.UString("language", "EN"), + tempUnit: localConfig.UString("tempUnit", "C"), + } + + settings.colors.current = localConfig.UString("colors.current", "green") + + return &settings +} diff --git a/modules/weatherservices/weather/widget.go b/modules/weatherservices/weather/widget.go index b7dba99e..13bcb5ed 100644 --- a/modules/weatherservices/weather/widget.go +++ b/modules/weatherservices/weather/widget.go @@ -1,8 +1,6 @@ package weather import ( - "os" - owm "github.com/briandowns/openweathermap" "github.com/gdamore/tcell" "github.com/rivo/tview" @@ -25,22 +23,24 @@ type Widget struct { wtf.HelpfulWidget wtf.TextWidget - APIKey string - Data []*owm.CurrentWeatherData - Idx int + // APIKey string + Data []*owm.CurrentWeatherData + Idx int + settings *Settings } // NewWidget creates and returns a new instance of the weather Widget. -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { - configKey := "weather" +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Weather", configKey, true), + TextWidget: wtf.NewTextWidget(app, "Weather", "weather", true), - Idx: 0, + Idx: 0, + settings: settings, } - widget.loadAPICredentials() + // widget.loadAPICredentials() + // widget.APIKey widget.HelpfulWidget.SetView(widget.View) widget.View.SetInputCapture(widget.keyboardIntercept) @@ -57,7 +57,7 @@ func (widget *Widget) Fetch(cityIDs []int) []*owm.CurrentWeatherData { data := []*owm.CurrentWeatherData{} for _, cityID := range cityIDs { - result, err := widget.currentWeather(widget.APIKey, cityID) + result, err := widget.currentWeather(cityID) if err == nil { data = append(data, result) } @@ -70,7 +70,7 @@ func (widget *Widget) Fetch(cityIDs []int) []*owm.CurrentWeatherData { // widget's view for rendering func (widget *Widget) Refresh() { if widget.apiKeyValid() { - widget.Data = widget.Fetch(wtf.ToInts(wtf.Config.UList("wtf.mods.weather.cityids", widget.defaultCityCodes()))) + widget.Data = widget.Fetch(wtf.ToInts(widget.settings.cityIDs)) } widget.display() @@ -101,11 +101,11 @@ func (widget *Widget) Prev() { /* -------------------- Unexported Functions -------------------- */ func (widget *Widget) apiKeyValid() bool { - if widget.APIKey == "" { + if widget.settings.apiKey == "" { return false } - if len(widget.APIKey) != 32 { + if len(widget.settings.apiKey) != 32 { return false } @@ -124,11 +124,11 @@ func (widget *Widget) currentData() *owm.CurrentWeatherData { return widget.Data[widget.Idx] } -func (widget *Widget) currentWeather(apiKey string, cityCode int) (*owm.CurrentWeatherData, error) { +func (widget *Widget) currentWeather(cityCode int) (*owm.CurrentWeatherData, error) { weather, err := owm.NewCurrent( - wtf.Config.UString("wtf.mods.weather.tempUnit", "C"), - wtf.Config.UString("wtf.mods.weather.language", "EN"), - apiKey, + widget.settings.tempUnit, + widget.settings.language, + widget.settings.apiKey, ) if err != nil { return nil, err @@ -142,17 +142,6 @@ func (widget *Widget) currentWeather(apiKey string, cityCode int) (*owm.CurrentW return weather, nil } -func (widget *Widget) defaultCityCodes() []interface{} { - defaultArr := []int{3370352} - - var defaults = make([]interface{}, len(defaultArr)) - for i, d := range defaultArr { - defaults[i] = d - } - - return defaults -} - func (widget *Widget) keyboardIntercept(event *tcell.EventKey) *tcell.EventKey { switch string(event.Rune()) { case "/": @@ -177,12 +166,3 @@ func (widget *Widget) keyboardIntercept(event *tcell.EventKey) *tcell.EventKey { return event } } - -// loadAPICredentials loads the API authentication credentials for this module -// First checks to see if they're in the config file. If not, checks the ENV var -func (widget *Widget) loadAPICredentials() { - widget.APIKey = wtf.Config.UString( - "wtf.mods.weather.apiKey", - os.Getenv("WTF_OWM_API_KEY"), - ) -} From 4b3f957c61dbc169b40af4eef41453bb6c883b3a Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 21:40:53 -0700 Subject: [PATCH 46/60] WTF-400 Zendesk extracted to new config format --- main.go | 3 ++- modules/zendesk/client.go | 27 ++++----------------------- modules/zendesk/settings.go | 32 ++++++++++++++++++++++++++++++++ modules/zendesk/tickets.go | 10 +++++----- modules/zendesk/widget.go | 10 ++++++---- 5 files changed, 49 insertions(+), 33 deletions(-) create mode 100644 modules/zendesk/settings.go diff --git a/main.go b/main.go index 2ac8b77b..a520065c 100644 --- a/main.go +++ b/main.go @@ -313,7 +313,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := weather.NewSettingsFromYAML(wtf.Config) widget = weather.NewWidget(app, pages, settings) case "zendesk": - widget = zendesk.NewWidget(app) + settings := zendesk.NewSettingsFromYAML(wtf.Config) + widget = zendesk.NewWidget(app, settings) default: widget = unknown.NewWidget(app, widgetName) } diff --git a/modules/zendesk/client.go b/modules/zendesk/client.go index e093a7e5..9bdbd564 100644 --- a/modules/zendesk/client.go +++ b/modules/zendesk/client.go @@ -6,9 +6,6 @@ import ( "io/ioutil" "log" "net/http" - "os" - - "github.com/wtfutil/wtf/wtf" ) type Resource struct { @@ -16,34 +13,20 @@ type Resource struct { Raw string } -func apiKey() string { - return wtf.Config.UString( - "wtf.mods.zendesk.apiKey", - os.Getenv("ZENDESK_API"), - ) -} - -func subdomain() string { - return wtf.Config.UString( - "wtf.mods.zendesk.subdomain", - os.Getenv("ZENDESK_SUBDOMAIN"), - ) -} - func errHandler(err error) { if err != nil { log.Print(err) } } -func api(key string, meth string, path string, params string) (*Resource, error) { +func (widget *Widget) api(meth string, path string, params string) (*Resource, error) { trn := &http.Transport{} client := &http.Client{ Transport: trn, } - baseURL := fmt.Sprintf("https://%v.zendesk.com/api/v2", subdomain()) + baseURL := fmt.Sprintf("https://%v.zendesk.com/api/v2", widget.settings.subdomain) URL := baseURL + "/tickets.json?sort_by=status" req, err := http.NewRequest(meth, URL, bytes.NewBufferString(params)) @@ -53,9 +36,8 @@ func api(key string, meth string, path string, params string) (*Resource, error) req.Header.Add("Content-Type", "application/json") - username := wtf.Config.UString("wtf.mods.zendesk.username") - apiUser := fmt.Sprintf("%v/token", username) - req.SetBasicAuth(apiUser, key) + apiUser := fmt.Sprintf("%v/token", widget.settings.username) + req.SetBasicAuth(apiUser, widget.settings.apiKey) resp, err := client.Do(req) if err != nil { @@ -70,5 +52,4 @@ func api(key string, meth string, path string, params string) (*Resource, error) } return &Resource{Response: &resp, Raw: string(data)}, nil - } diff --git a/modules/zendesk/settings.go b/modules/zendesk/settings.go new file mode 100644 index 00000000..9bc1a407 --- /dev/null +++ b/modules/zendesk/settings.go @@ -0,0 +1,32 @@ +package zendesk + +import ( + "os" + + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common + + apiKey string + status string + subdomain string + username string +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods.zendesk") + + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("ZENDESK_API")), + status: localConfig.UString("status"), + subdomain: localConfig.UString("subdomain", os.Getenv("ZENDESK_SUBDOMAIN")), + username: localConfig.UString("username"), + } + + return &settings +} diff --git a/modules/zendesk/tickets.go b/modules/zendesk/tickets.go index a5ba7575..6bc3bbfa 100644 --- a/modules/zendesk/tickets.go +++ b/modules/zendesk/tickets.go @@ -45,7 +45,7 @@ type Ticket struct { Fields interface{} `json:"fields"` } -func listTickets(pag ...string) (*TicketArray, error) { +func (widget *Widget) listTickets(pag ...string) (*TicketArray, error) { TicketStruct := &TicketArray{} @@ -55,7 +55,7 @@ func listTickets(pag ...string) (*TicketArray, error) { } else { path = pag[0] } - resource, err := api(apiKey(), "GET", path, "") + resource, err := widget.api("GET", path, "") if err != nil { return nil, err } @@ -66,14 +66,14 @@ func listTickets(pag ...string) (*TicketArray, error) { } -func newTickets(ticketStatus string) (*TicketArray, error) { +func (widget *Widget) newTickets() (*TicketArray, error) { newTicketArray := &TicketArray{} - tickets, err := listTickets() + tickets, err := widget.listTickets(widget.settings.apiKey) if err != nil { log.Fatal(err) } for _, Ticket := range tickets.Tickets { - if Ticket.Status == ticketStatus && Ticket.Status != "closed" && Ticket.Status != "solved" { + if Ticket.Status == widget.settings.status && Ticket.Status != "closed" && Ticket.Status != "solved" { newTicketArray.Tickets = append(newTicketArray.Tickets, Ticket) } } diff --git a/modules/zendesk/widget.go b/modules/zendesk/widget.go index 153a954f..eb00b0c6 100644 --- a/modules/zendesk/widget.go +++ b/modules/zendesk/widget.go @@ -14,11 +14,14 @@ type Widget struct { result *TicketArray selected int + settings *Settings } -func NewWidget(app *tview.Application) *Widget { +func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, "Zendesk", "zendesk", true), + + settings: settings, } widget.View.SetInputCapture(widget.keyboardIntercept) @@ -28,8 +31,7 @@ func NewWidget(app *tview.Application) *Widget { /* -------------------- Exported Functions -------------------- */ func (widget *Widget) Refresh() { - ticketStatus := wtf.Config.UString("wtf.mods.zendesk.status") - ticketArray, err := newTickets(ticketStatus) + ticketArray, err := widget.newTickets() ticketArray.Count = len(ticketArray.Tickets) if err != nil { log.Fatal(err) @@ -102,7 +104,7 @@ func (widget *Widget) openTicket() { sel := widget.selected if sel >= 0 && widget.result != nil && sel < len(widget.result.Tickets) { issue := &widget.result.Tickets[widget.selected] - ticketUrl := fmt.Sprintf("https://%s.zendesk.com/agent/tickets/%d", subdomain(), issue.Id) + ticketUrl := fmt.Sprintf("https://%s.zendesk.com/agent/tickets/%d", widget.settings.subdomain, issue.Id) wtf.OpenFile(ticketUrl) } } From 6f98ecccf7ffdbde6a76380f62728aed04ab51f0 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 21:43:46 -0700 Subject: [PATCH 47/60] WTF-400 Unknown extracted to new config format --- main.go | 3 ++- modules/unknown/settings.go | 18 ++++++++++++++++++ modules/unknown/widget.go | 7 +++++-- 3 files changed, 25 insertions(+), 3 deletions(-) create mode 100644 modules/unknown/settings.go diff --git a/main.go b/main.go index a520065c..bc428619 100644 --- a/main.go +++ b/main.go @@ -316,7 +316,8 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w settings := zendesk.NewSettingsFromYAML(wtf.Config) widget = zendesk.NewWidget(app, settings) default: - widget = unknown.NewWidget(app, widgetName) + settings := unknown.NewSettingsFromYAML(wtf.Config) + widget = unknown.NewWidget(app, widgetName, settings) } return widget diff --git a/modules/unknown/settings.go b/modules/unknown/settings.go new file mode 100644 index 00000000..a6530cdc --- /dev/null +++ b/modules/unknown/settings.go @@ -0,0 +1,18 @@ +package unknown + +import ( + "github.com/olebedev/config" + "github.com/wtfutil/wtf/cfg" +) + +type Settings struct { + common *cfg.Common +} + +func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { + settings := Settings{ + common: cfg.NewCommonSettingsFromYAML(ymlConfig), + } + + return &settings +} diff --git a/modules/unknown/widget.go b/modules/unknown/widget.go index 88653d90..6be2c567 100644 --- a/modules/unknown/widget.go +++ b/modules/unknown/widget.go @@ -9,11 +9,15 @@ import ( type Widget struct { wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application, name string) *Widget { +func NewWidget(app *tview.Application, name string, settings *Settings) *Widget { widget := Widget{ TextWidget: wtf.NewTextWidget(app, name, name, false), + + settings: settings, } return &widget @@ -22,7 +26,6 @@ func NewWidget(app *tview.Application, name string) *Widget { /* -------------------- Exported Functions -------------------- */ func (widget *Widget) Refresh() { - widget.View.SetTitle(widget.ContextualTitle(fmt.Sprintf("%s", widget.Name()))) widget.View.Clear() From 2807a2200e7f7ad239a09d07ea301854d38ee085 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 21:47:51 -0700 Subject: [PATCH 48/60] WTF-400 Fix missed wtf.Config occurrances --- modules/clocks/clock_collection.go | 6 ++---- modules/clocks/widget.go | 2 +- modules/cmdrunner/settings.go | 2 +- modules/rollbar/client.go | 14 +++++--------- modules/rollbar/settings.go | 2 +- modules/rollbar/widget.go | 6 +++++- modules/travisci/widget.go | 2 +- 7 files changed, 16 insertions(+), 18 deletions(-) diff --git a/modules/clocks/clock_collection.go b/modules/clocks/clock_collection.go index 6ca8f0c8..754a3f4c 100644 --- a/modules/clocks/clock_collection.go +++ b/modules/clocks/clock_collection.go @@ -3,16 +3,14 @@ package clocks import ( "sort" "time" - - "github.com/wtfutil/wtf/wtf" ) type ClockCollection struct { Clocks []Clock } -func (clocks *ClockCollection) Sorted() []Clock { - if "chronological" == wtf.Config.UString("wtf.mods.clocks.sort", "alphabetical") { +func (clocks *ClockCollection) Sorted(sortOrder string) []Clock { + if sortOrder == "chronological" { clocks.SortedChronologically() } else { clocks.SortedAlphabetically() diff --git a/modules/clocks/widget.go b/modules/clocks/widget.go index 11cfc18d..26ee1918 100644 --- a/modules/clocks/widget.go +++ b/modules/clocks/widget.go @@ -34,7 +34,7 @@ func NewWidget(app *tview.Application, settings *Settings) *Widget { /* -------------------- Exported Functions -------------------- */ func (widget *Widget) Refresh() { - widget.display(widget.clockColl.Sorted(), widget.dateFormat, widget.timeFormat) + widget.display(widget.clockColl.Sorted(widget.settings.sort), widget.dateFormat, widget.timeFormat) } /* -------------------- Unexported Functions -------------------- */ diff --git a/modules/cmdrunner/settings.go b/modules/cmdrunner/settings.go index 1629e25f..0bfae27a 100644 --- a/modules/cmdrunner/settings.go +++ b/modules/cmdrunner/settings.go @@ -19,7 +19,7 @@ func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { settings := Settings{ common: cfg.NewCommonSettingsFromYAML(ymlConfig), - args: wtf.ToStrs(wtf.Config.UList("args")), + args: wtf.ToStrs(localConfig.UList("args")), cmd: localConfig.UString("cmd"), } diff --git a/modules/rollbar/client.go b/modules/rollbar/client.go index 431b87c8..90337ae3 100644 --- a/modules/rollbar/client.go +++ b/modules/rollbar/client.go @@ -8,16 +8,14 @@ import ( "io/ioutil" "net/http" "net/url" - - "github.com/wtfutil/wtf/wtf" ) -func CurrentActiveItems(accessToken string) (*ActiveItems, error) { +func CurrentActiveItems(accessToken, assignedToName string, activeOnly bool) (*ActiveItems, error) { items := &ActiveItems{} rollbarAPIURL.Host = "api.rollbar.com" rollbarAPIURL.Path = "/api/1/items" - resp, err := rollbarItemRequest(accessToken) + resp, err := rollbarItemRequest(accessToken, assignedToName, activeOnly) if err != nil { return items, err } @@ -33,13 +31,11 @@ var ( rollbarAPIURL = &url.URL{Scheme: "https"} ) -func rollbarItemRequest(accessToken string) (*http.Response, error) { +func rollbarItemRequest(accessToken, assignedToName string, activeOnly bool) (*http.Response, error) { params := url.Values{} params.Add("access_token", accessToken) - userName := wtf.Config.UString("wtf.mods.rollbar.assignedToName", "") - params.Add("assigned_user", userName) - active := wtf.Config.UBool("wtf.mods.rollbar.activeOnly", false) - if active { + params.Add("assigned_user", assignedToName) + if activeOnly { params.Add("status", "active") } diff --git a/modules/rollbar/settings.go b/modules/rollbar/settings.go index 84ddff73..ac870b1d 100644 --- a/modules/rollbar/settings.go +++ b/modules/rollbar/settings.go @@ -23,7 +23,7 @@ func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { common: cfg.NewCommonSettingsFromYAML(ymlConfig), accessToken: localConfig.UString("accessToken"), - activeOnly: localConfig.UBool("activeOnly"), + activeOnly: localConfig.UBool("activeOnly", false), assignedToName: localConfig.UString("assignedToName"), count: localConfig.UInt("count", 10), projectName: localConfig.UString("projectName", "Items"), diff --git a/modules/rollbar/widget.go b/modules/rollbar/widget.go index 245081f9..04c6d250 100644 --- a/modules/rollbar/widget.go +++ b/modules/rollbar/widget.go @@ -55,7 +55,11 @@ func (widget *Widget) Refresh() { return } - items, err := CurrentActiveItems(widget.settings.accessToken) + items, err := CurrentActiveItems( + widget.settings.accessToken, + widget.settings.assignedToName, + widget.settings.activeOnly, + ) if err != nil { widget.View.SetWrap(true) diff --git a/modules/travisci/widget.go b/modules/travisci/widget.go index e6f21346..151b9708 100644 --- a/modules/travisci/widget.go +++ b/modules/travisci/widget.go @@ -150,7 +150,7 @@ func (widget *Widget) openBuild() { sel := widget.selected if sel >= 0 && widget.builds != nil && sel < len(widget.builds.Builds) { build := &widget.builds.Builds[widget.selected] - travisHost := TRAVIS_HOSTS[wtf.Config.UBool("wtf.mods.travisci.pro", false)] + travisHost := TRAVIS_HOSTS[widget.settings.pro] wtf.OpenFile(fmt.Sprintf("https://%s/%s/%s/%d", travisHost, build.Repository.Slug, "builds", build.ID)) } } From d174bd1497842adc9464b391bdf113d5996ad8db Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Tue, 16 Apr 2019 21:56:51 -0700 Subject: [PATCH 49/60] WTF-400 Add settings to the template (a settings template as yet to be created) --- generator/textwidget.tpl | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/generator/textwidget.tpl b/generator/textwidget.tpl index 3bed5c5c..e3ebd214 100644 --- a/generator/textwidget.tpl +++ b/generator/textwidget.tpl @@ -16,12 +16,16 @@ const HelpText = ` type Widget struct { wtf.HelpfulWidget wtf.TextWidget + + settings *Settings } -func NewWidget(app *tview.Application, pages *tview.Pages) *Widget { +func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), TextWidget: wtf.NewTextWidget(app, "{{(Title .Name)}}", "{{(Lower .Name)}}", true), + + settings: settings, } widget.HelpfulWidget.SetView(widget.View) From b50c762dabfd45546d0ada997eabb6361baaf933 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Wed, 17 Apr 2019 17:16:26 -0700 Subject: [PATCH 50/60] WTF-400 Move name and configKey values from widget to settings --- .vscode/settings.json | 3 + cfg/common_settings.go | 14 ++- logger/settings.go | 6 +- main.go | 90 +++++++++---------- modules/bamboohr/settings.go | 21 +++-- modules/bamboohr/widget.go | 6 +- modules/circleci/settings.go | 11 ++- modules/circleci/widget.go | 2 +- modules/clocks/setting.go | 8 +- modules/clocks/widget.go | 2 +- modules/cmdrunner/settings.go | 8 +- modules/cmdrunner/widget.go | 2 +- modules/cryptoexchanges/bittrex/settings.go | 8 +- modules/cryptoexchanges/bittrex/widget.go | 2 +- .../cryptoexchanges/blockfolio/settings.go | 8 +- modules/cryptoexchanges/blockfolio/widget.go | 2 +- .../cryptolive/price/settings.go | 8 +- .../cryptoexchanges/cryptolive/settings.go | 16 ++-- .../cryptolive/toplist/settings.go | 8 +- modules/cryptoexchanges/cryptolive/widget.go | 2 +- modules/datadog/settings.go | 9 +- modules/datadog/widget.go | 2 +- modules/gcal/settings.go | 8 +- modules/gcal/widget.go | 2 +- modules/gerrit/settings.go | 8 +- modules/gerrit/widget.go | 2 +- modules/git/settings.go | 8 +- modules/git/widget.go | 2 +- modules/github/settings.go | 8 +- modules/github/widget.go | 2 +- modules/gitlab/settings.go | 8 +- modules/gitlab/widget.go | 2 +- modules/gitter/settings.go | 8 +- modules/gitter/widget.go | 2 +- modules/gspreadsheets/settings.go | 8 +- modules/gspreadsheets/widget.go | 2 +- modules/hackernews/settings.go | 8 +- modules/hackernews/widget.go | 2 +- modules/ipaddresses/ipapi/settings.go | 8 +- modules/ipaddresses/ipapi/widget.go | 2 +- modules/ipaddresses/ipinfo/settings.go | 8 +- modules/ipaddresses/ipinfo/widget.go | 2 +- modules/jenkins/settings.go | 8 +- modules/jenkins/widget.go | 2 +- modules/jira/settings.go | 8 +- modules/jira/widget.go | 2 +- modules/mercurial/settings.go | 8 +- modules/mercurial/widget.go | 4 +- modules/nbascore/settings.go | 6 +- modules/nbascore/widget.go | 2 +- modules/newrelic/settings.go | 8 +- modules/newrelic/widget.go | 2 +- modules/opsgenie/settings.go | 8 +- modules/opsgenie/widget.go | 2 +- modules/pagerduty/settings.go | 8 +- modules/pagerduty/widget.go | 2 +- modules/power/settings.go | 6 +- modules/power/widget.go | 2 +- modules/resourceusage/settings.go | 6 +- modules/resourceusage/widget.go | 2 +- modules/rollbar/settings.go | 8 +- modules/rollbar/widget.go | 2 +- modules/security/settings.go | 6 +- modules/security/widget.go | 2 +- modules/spotify/settings.go | 6 +- modules/spotify/widget.go | 2 +- modules/spotifyweb/settings.go | 8 +- modules/spotifyweb/widget.go | 2 +- modules/status/settings.go | 6 +- modules/status/widget.go | 2 +- modules/system/settings.go | 6 +- modules/system/widget.go | 2 +- modules/textfile/settings.go | 8 +- modules/textfile/widget.go | 4 +- modules/todo/settings.go | 8 +- modules/todo/widget.go | 2 +- modules/todoist/settings.go | 8 +- modules/todoist/widget.go | 2 +- modules/travisci/settings.go | 10 ++- modules/travisci/widget.go | 2 +- modules/trello/settings.go | 8 +- modules/trello/widget.go | 2 +- modules/twitter/settings.go | 8 +- modules/twitter/widget.go | 4 +- modules/unknown/settings.go | 6 +- modules/victorops/settings.go | 8 +- modules/victorops/widget.go | 2 +- .../weatherservices/prettyweather/settings.go | 8 +- .../weatherservices/prettyweather/widget.go | 2 +- modules/weatherservices/weather/settings.go | 8 +- modules/weatherservices/weather/widget.go | 2 +- modules/zendesk/settings.go | 8 +- modules/zendesk/widget.go | 2 +- 93 files changed, 351 insertions(+), 237 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..56422821 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "workbench.colorCustomizations": {} +} \ No newline at end of file diff --git a/cfg/common_settings.go b/cfg/common_settings.go index ef0d29a2..2bc4450f 100644 --- a/cfg/common_settings.go +++ b/cfg/common_settings.go @@ -15,6 +15,11 @@ type Colors struct { Text string } +type Module struct { + ConfigKey string + Name string +} + type Position struct { Height int Left int @@ -24,6 +29,7 @@ type Position struct { type Common struct { Colors + Module Position Enabled bool @@ -31,7 +37,7 @@ type Common struct { Title string } -func NewCommonSettingsFromYAML(ymlConfig *config.Config) *Common { +func NewCommonSettingsFromYAML(name, configKey string, ymlConfig *config.Config) *Common { common := Common{ Colors: Colors{ Background: ymlConfig.UString("wtf.colors.background", "black"), @@ -43,6 +49,12 @@ func NewCommonSettingsFromYAML(ymlConfig *config.Config) *Common { HighlightBack: ymlConfig.UString("wtf.colors.highlight.back"), Text: ymlConfig.UString("wtf.colors.text", "white"), }, + + Module: Module{ + ConfigKey: configKey, + Name: name, + }, + Position: Position{}, } diff --git a/logger/settings.go b/logger/settings.go index e880879a..ba61ce9e 100644 --- a/logger/settings.go +++ b/logger/settings.go @@ -5,13 +5,15 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "logger" + type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } return &settings diff --git a/main.go b/main.go index bc428619..1afc6ca1 100644 --- a/main.go +++ b/main.go @@ -182,141 +182,141 @@ func makeWidget(app *tview.Application, pages *tview.Pages, widgetName string) w // Always in alphabetical order switch widgetName { case "bamboohr": - settings := bamboohr.NewSettingsFromYAML(wtf.Config) + settings := bamboohr.NewSettingsFromYAML("BambooHR", wtf.Config) widget = bamboohr.NewWidget(app, settings) case "bargraph": widget = bargraph.NewWidget(app) case "bittrex": - settings := bittrex.NewSettingsFromYAML(wtf.Config) + settings := bittrex.NewSettingsFromYAML("Bittrex", wtf.Config) widget = bittrex.NewWidget(app, settings) case "blockfolio": - settings := blockfolio.NewSettingsFromYAML(wtf.Config) + settings := blockfolio.NewSettingsFromYAML("Blockfolio", wtf.Config) widget = blockfolio.NewWidget(app, settings) case "circleci": - settings := circleci.NewSettingsFromYAML(wtf.Config) + settings := circleci.NewSettingsFromYAML("CircleCI", wtf.Config) widget = circleci.NewWidget(app, settings) case "clocks": - settings := clocks.NewSettingsFromYAML(wtf.Config) + settings := clocks.NewSettingsFromYAML("Clocks", wtf.Config) widget = clocks.NewWidget(app, settings) case "cmdrunner": - settings := cmdrunner.NewSettingsFromYAML(wtf.Config) + settings := cmdrunner.NewSettingsFromYAML("CmdRunner", wtf.Config) widget = cmdrunner.NewWidget(app, settings) case "cryptolive": - settings := cryptolive.NewSettingsFromYAML(wtf.Config) + settings := cryptolive.NewSettingsFromYAML("CryptoLive", wtf.Config) widget = cryptolive.NewWidget(app, settings) case "datadog": - settings := datadog.NewSettingsFromYAML(wtf.Config) + settings := datadog.NewSettingsFromYAML("DataDog", wtf.Config) widget = datadog.NewWidget(app, settings) case "gcal": - settings := gcal.NewSettingsFromYAML(wtf.Config) + settings := gcal.NewSettingsFromYAML("Calendar", wtf.Config) widget = gcal.NewWidget(app, settings) case "gerrit": - settings := gerrit.NewSettingsFromYAML(wtf.Config) + settings := gerrit.NewSettingsFromYAML("Gerrit", wtf.Config) widget = gerrit.NewWidget(app, pages, settings) case "git": - settings := git.NewSettingsFromYAML(wtf.Config) + settings := git.NewSettingsFromYAML("Git", wtf.Config) widget = git.NewWidget(app, pages, settings) case "github": - settings := github.NewSettingsFromYAML(wtf.Config) + settings := github.NewSettingsFromYAML("GitHub", wtf.Config) widget = github.NewWidget(app, pages, settings) case "gitlab": - settings := gitlab.NewSettingsFromYAML(wtf.Config) + settings := gitlab.NewSettingsFromYAML("GitLab", wtf.Config) widget = gitlab.NewWidget(app, pages, settings) case "gitter": - settings := gitter.NewSettingsFromYAML(wtf.Config) + settings := gitter.NewSettingsFromYAML("Gitter", wtf.Config) widget = gitter.NewWidget(app, pages, settings) case "gspreadsheets": - settings := gspreadsheets.NewSettingsFromYAML(wtf.Config) + settings := gspreadsheets.NewSettingsFromYAML("Google Spreadsheets", wtf.Config) widget = gspreadsheets.NewWidget(app, settings) case "hackernews": - settings := hackernews.NewSettingsFromYAML(wtf.Config) + settings := hackernews.NewSettingsFromYAML("HackerNews", wtf.Config) widget = hackernews.NewWidget(app, pages, settings) case "ipapi": - settings := ipapi.NewSettingsFromYAML(wtf.Config) + settings := ipapi.NewSettingsFromYAML("IPAPI", wtf.Config) widget = ipapi.NewWidget(app, settings) case "ipinfo": - settings := ipinfo.NewSettingsFromYAML(wtf.Config) + settings := ipinfo.NewSettingsFromYAML("IPInfo", wtf.Config) widget = ipinfo.NewWidget(app, settings) case "jenkins": - settings := jenkins.NewSettingsFromYAML(wtf.Config) + settings := jenkins.NewSettingsFromYAML("Jenkins", wtf.Config) widget = jenkins.NewWidget(app, pages, settings) case "jira": - settings := jira.NewSettingsFromYAML(wtf.Config) + settings := jira.NewSettingsFromYAML("Jira", wtf.Config) widget = jira.NewWidget(app, pages, settings) case "logger": - settings := logger.NewSettingsFromYAML(wtf.Config) + settings := logger.NewSettingsFromYAML("Log", wtf.Config) widget = logger.NewWidget(app, settings) case "mercurial": - settings := mercurial.NewSettingsFromYAML(wtf.Config) + settings := mercurial.NewSettingsFromYAML("Mercurial", wtf.Config) widget = mercurial.NewWidget(app, pages, settings) case "nbascore": - settings := nbascore.NewSettingsFromYAML(wtf.Config) + settings := nbascore.NewSettingsFromYAML("NBA Score", wtf.Config) widget = nbascore.NewWidget(app, pages, settings) case "newrelic": - settings := newrelic.NewSettingsFromYAML(wtf.Config) + settings := newrelic.NewSettingsFromYAML("NewRelic", wtf.Config) widget = newrelic.NewWidget(app, settings) case "opsgenie": - settings := opsgenie.NewSettingsFromYAML(wtf.Config) + settings := opsgenie.NewSettingsFromYAML("OpsGenie", wtf.Config) widget = opsgenie.NewWidget(app, settings) case "pagerduty": - settings := pagerduty.NewSettingsFromYAML(wtf.Config) + settings := pagerduty.NewSettingsFromYAML("PagerDuty", wtf.Config) widget = pagerduty.NewWidget(app, settings) case "power": - settings := power.NewSettingsFromYAML(wtf.Config) + settings := power.NewSettingsFromYAML("Power", wtf.Config) widget = power.NewWidget(app, settings) case "prettyweather": - settings := prettyweather.NewSettingsFromYAML(wtf.Config) + settings := prettyweather.NewSettingsFromYAML("Pretty Weather", wtf.Config) widget = prettyweather.NewWidget(app, settings) case "resourceusage": - settings := resourceusage.NewSettingsFromYAML(wtf.Config) + settings := resourceusage.NewSettingsFromYAML("Resource Usage", wtf.Config) widget = resourceusage.NewWidget(app, settings) case "rollbar": - settings := rollbar.NewSettingsFromYAML(wtf.Config) + settings := rollbar.NewSettingsFromYAML("Rollbar", wtf.Config) widget = rollbar.NewWidget(app, pages, settings) case "security": - settings := security.NewSettingsFromYAML(wtf.Config) + settings := security.NewSettingsFromYAML("Security", wtf.Config) widget = security.NewWidget(app, settings) case "spotify": - settings := spotify.NewSettingsFromYAML(wtf.Config) + settings := spotify.NewSettingsFromYAML("Spotify", wtf.Config) widget = spotify.NewWidget(app, pages, settings) case "spotifyweb": - settings := spotifyweb.NewSettingsFromYAML(wtf.Config) + settings := spotifyweb.NewSettingsFromYAML("Spotify Web", wtf.Config) widget = spotifyweb.NewWidget(app, pages, settings) case "status": - settings := status.NewSettingsFromYAML(wtf.Config) + settings := status.NewSettingsFromYAML("Status", wtf.Config) widget = status.NewWidget(app, settings) case "system": - settings := system.NewSettingsFromYAML(wtf.Config) + settings := system.NewSettingsFromYAML("System", wtf.Config) widget = system.NewWidget(app, date, version, settings) case "textfile": - settings := textfile.NewSettingsFromYAML(wtf.Config) + settings := textfile.NewSettingsFromYAML("Textfile", wtf.Config) widget = textfile.NewWidget(app, pages, settings) case "todo": - settings := todo.NewSettingsFromYAML(wtf.Config) + settings := todo.NewSettingsFromYAML("Todo", wtf.Config) widget = todo.NewWidget(app, pages, settings) case "todoist": - settings := todoist.NewSettingsFromYAML(wtf.Config) + settings := todoist.NewSettingsFromYAML("Todoist", wtf.Config) widget = todoist.NewWidget(app, pages, settings) case "travisci": - settings := travisci.NewSettingsFromYAML(wtf.Config) + settings := travisci.NewSettingsFromYAML("TravisCI", wtf.Config) widget = travisci.NewWidget(app, pages, settings) case "trello": - settings := trello.NewSettingsFromYAML(wtf.Config) + settings := trello.NewSettingsFromYAML("Trello", wtf.Config) widget = trello.NewWidget(app, settings) case "twitter": - settings := twitter.NewSettingsFromYAML(wtf.Config) + settings := twitter.NewSettingsFromYAML("Twitter", wtf.Config) widget = twitter.NewWidget(app, pages, settings) case "victorops": - settings := victorops.NewSettingsFromYAML(wtf.Config) + settings := victorops.NewSettingsFromYAML("VictorOps - OnCall", wtf.Config) widget = victorops.NewWidget(app, settings) case "weather": - settings := weather.NewSettingsFromYAML(wtf.Config) + settings := weather.NewSettingsFromYAML("Weather", wtf.Config) widget = weather.NewWidget(app, pages, settings) case "zendesk": - settings := zendesk.NewSettingsFromYAML(wtf.Config) + settings := zendesk.NewSettingsFromYAML("Zendesk", wtf.Config) widget = zendesk.NewWidget(app, settings) default: - settings := unknown.NewSettingsFromYAML(wtf.Config) + settings := unknown.NewSettingsFromYAML(widgetName, wtf.Config) widget = unknown.NewWidget(app, widgetName, settings) } diff --git a/modules/bamboohr/settings.go b/modules/bamboohr/settings.go index 223b8c32..a8a61d0e 100644 --- a/modules/bamboohr/settings.go +++ b/modules/bamboohr/settings.go @@ -7,20 +7,23 @@ import ( "github.com/wtfutil/wtf/cfg" ) -type Settings struct { - Common *cfg.Common +const configKey = "bamboohr" - APIKey string - Subdomain string +type Settings struct { + common *cfg.Common + + apiKey string + subdomain string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.bamboohr") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - Common: cfg.NewCommonSettingsFromYAML(ymlConfig), - APIKey: localConfig.UString("apiKey", os.Getenv("WTF_BAMBOO_HR_TOKEN")), - Subdomain: localConfig.UString("subdomain", os.Getenv("WTF_BAMBOO_HR_SUBDOMAIN")), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), + + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_BAMBOO_HR_TOKEN")), + subdomain: localConfig.UString("subdomain", os.Getenv("WTF_BAMBOO_HR_SUBDOMAIN")), } return &settings diff --git a/modules/bamboohr/widget.go b/modules/bamboohr/widget.go index 5091cecb..3a37cc77 100644 --- a/modules/bamboohr/widget.go +++ b/modules/bamboohr/widget.go @@ -17,7 +17,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "BambooHR", "bamboohr", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } @@ -30,8 +30,8 @@ func NewWidget(app *tview.Application, settings *Settings) *Widget { func (widget *Widget) Refresh() { client := NewClient( APIURI, - widget.settings.APIKey, - widget.settings.Subdomain, + widget.settings.apiKey, + widget.settings.subdomain, ) todayItems := client.Away( diff --git a/modules/circleci/settings.go b/modules/circleci/settings.go index 2dcdffa9..59a74056 100644 --- a/modules/circleci/settings.go +++ b/modules/circleci/settings.go @@ -7,17 +7,20 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "circleci" + type Settings struct { - Common *cfg.Common + common *cfg.Common apiKey string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.circleci") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - Common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_CIRCLE_API_KEY")), } diff --git a/modules/circleci/widget.go b/modules/circleci/widget.go index 63faf855..0c654241 100644 --- a/modules/circleci/widget.go +++ b/modules/circleci/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "CircleCI", "circleci", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), Client: NewClient(settings.apiKey), settings: settings, diff --git a/modules/clocks/setting.go b/modules/clocks/setting.go index 3fbc856a..08297cc8 100644 --- a/modules/clocks/setting.go +++ b/modules/clocks/setting.go @@ -6,6 +6,8 @@ import ( "github.com/wtfutil/wtf/wtf" ) +const configKey = "clocks" + type colors struct { rows struct { even string @@ -23,11 +25,11 @@ type Settings struct { sort string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.clocks") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), dateFormat: localConfig.UString("dateFormat", wtf.SimpleDateFormat), timeFormat: localConfig.UString("timeFormat", wtf.SimpleTimeFormat), diff --git a/modules/clocks/widget.go b/modules/clocks/widget.go index 26ee1918..45ffb3d7 100644 --- a/modules/clocks/widget.go +++ b/modules/clocks/widget.go @@ -19,7 +19,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "World Clocks", "clocks", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, dateFormat: settings.dateFormat, diff --git a/modules/cmdrunner/settings.go b/modules/cmdrunner/settings.go index 0bfae27a..8c979a2a 100644 --- a/modules/cmdrunner/settings.go +++ b/modules/cmdrunner/settings.go @@ -6,6 +6,8 @@ import ( "github.com/wtfutil/wtf/wtf" ) +const configKey = "cmdrunner" + type Settings struct { common *cfg.Common @@ -13,11 +15,11 @@ type Settings struct { cmd string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.cmdrunner") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), args: wtf.ToStrs(localConfig.UList("args")), cmd: localConfig.UString("cmd"), diff --git a/modules/cmdrunner/widget.go b/modules/cmdrunner/widget.go index 5d1fd13c..ec613969 100644 --- a/modules/cmdrunner/widget.go +++ b/modules/cmdrunner/widget.go @@ -20,7 +20,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "CmdRunner", "cmdrunner", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), args: settings.args, cmd: settings.cmd, diff --git a/modules/cryptoexchanges/bittrex/settings.go b/modules/cryptoexchanges/bittrex/settings.go index 6da9111b..d35f7f53 100644 --- a/modules/cryptoexchanges/bittrex/settings.go +++ b/modules/cryptoexchanges/bittrex/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "bittrex" + type colors struct { base struct { name string @@ -24,11 +26,11 @@ type Settings struct { summary map[string]interface{} } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.bittrex") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } settings.colors.base.name = localConfig.UString("colors.base.name") diff --git a/modules/cryptoexchanges/bittrex/widget.go b/modules/cryptoexchanges/bittrex/widget.go index 532b93f7..70daaac7 100644 --- a/modules/cryptoexchanges/bittrex/widget.go +++ b/modules/cryptoexchanges/bittrex/widget.go @@ -27,7 +27,7 @@ type Widget struct { // NewWidget Make new instance of widget func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Bittrex", "bittrex", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, summaryList: summaryList{}, diff --git a/modules/cryptoexchanges/blockfolio/settings.go b/modules/cryptoexchanges/blockfolio/settings.go index 0ccb1320..958e0635 100644 --- a/modules/cryptoexchanges/blockfolio/settings.go +++ b/modules/cryptoexchanges/blockfolio/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "blockfolio" + type colors struct { name string grows string @@ -19,11 +21,11 @@ type Settings struct { displayHoldings bool } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.blockfolio") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), deviceToken: localConfig.UString("device_token"), displayHoldings: localConfig.UBool("displayHoldings", true), diff --git a/modules/cryptoexchanges/blockfolio/widget.go b/modules/cryptoexchanges/blockfolio/widget.go index 25dad3cb..9453da57 100644 --- a/modules/cryptoexchanges/blockfolio/widget.go +++ b/modules/cryptoexchanges/blockfolio/widget.go @@ -20,7 +20,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Blockfolio", "blockfolio", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), device_token: settings.deviceToken, settings: settings, diff --git a/modules/cryptoexchanges/cryptolive/price/settings.go b/modules/cryptoexchanges/cryptolive/price/settings.go index 2dd5cbef..1e1c66bf 100644 --- a/modules/cryptoexchanges/cryptolive/price/settings.go +++ b/modules/cryptoexchanges/cryptolive/price/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "price" + type colors struct { from struct { name string @@ -34,14 +36,14 @@ type Settings struct { top map[string]interface{} } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.cryptolive") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) currencies, _ := localConfig.Map("currencies") top, _ := localConfig.Map("top") settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), currencies: currencies, top: top, } diff --git a/modules/cryptoexchanges/cryptolive/settings.go b/modules/cryptoexchanges/cryptolive/settings.go index abffae4d..1ecc7049 100644 --- a/modules/cryptoexchanges/cryptolive/settings.go +++ b/modules/cryptoexchanges/cryptolive/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/modules/cryptoexchanges/cryptolive/toplist" ) +const configKey = "cryptolive" + type colors struct { from struct { name string @@ -31,7 +33,8 @@ type colors struct { type Settings struct { colors - common *cfg.Common + common *cfg.Common + currencies map[string]interface{} top map[string]interface{} @@ -39,19 +42,20 @@ type Settings struct { toplistSettings *toplist.Settings } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.cryptolive") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) currencies, _ := localConfig.Map("currencies") top, _ := localConfig.Map("top") settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), + currencies: currencies, top: top, - priceSettings: price.NewSettingsFromYAML(ymlConfig), - toplistSettings: toplist.NewSettingsFromYAML(ymlConfig), + priceSettings: price.NewSettingsFromYAML(name, ymlConfig), + toplistSettings: toplist.NewSettingsFromYAML(name, ymlConfig), } settings.colors.from.name = localConfig.UString("colors.from.name") diff --git a/modules/cryptoexchanges/cryptolive/toplist/settings.go b/modules/cryptoexchanges/cryptolive/toplist/settings.go index d7844192..97d23eea 100644 --- a/modules/cryptoexchanges/cryptolive/toplist/settings.go +++ b/modules/cryptoexchanges/cryptolive/toplist/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "toplist" + type colors struct { from struct { name string @@ -34,14 +36,14 @@ type Settings struct { top map[string]interface{} } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.cryptolive") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) currencies, _ := localConfig.Map("currencies") top, _ := localConfig.Map("top") settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), currencies: currencies, top: top, } diff --git a/modules/cryptoexchanges/cryptolive/widget.go b/modules/cryptoexchanges/cryptolive/widget.go index 199e1bf2..39d2f14c 100644 --- a/modules/cryptoexchanges/cryptolive/widget.go +++ b/modules/cryptoexchanges/cryptolive/widget.go @@ -22,7 +22,7 @@ type Widget struct { // NewWidget Make new instance of widget func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "CryptoLive", "cryptolive", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), priceWidget: price.NewWidget(settings.priceSettings), toplistWidget: toplist.NewWidget(settings.toplistSettings), diff --git a/modules/datadog/settings.go b/modules/datadog/settings.go index d448402a..f7f05f79 100644 --- a/modules/datadog/settings.go +++ b/modules/datadog/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "datadog" + type Settings struct { common *cfg.Common @@ -15,11 +17,12 @@ type Settings struct { tags []interface{} } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.datadog") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), + apiKey: localConfig.UString("apiKey", os.Getenv("WTF_DATADOG_API_KEY")), applicationKey: localConfig.UString("applicationKey", os.Getenv("WTF_DATADOG_APPLICATION_KEY")), tags: localConfig.UList("monitors.tags"), diff --git a/modules/datadog/widget.go b/modules/datadog/widget.go index 71bb1212..275ec1fc 100644 --- a/modules/datadog/widget.go +++ b/modules/datadog/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Datadog", "datadog", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/gcal/settings.go b/modules/gcal/settings.go index 861b1c68..1c04d8a6 100644 --- a/modules/gcal/settings.go +++ b/modules/gcal/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "gcal" + type colors struct { day string description string @@ -30,11 +32,11 @@ type Settings struct { withLocation bool } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.gcal") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), conflictIcon: localConfig.UString("conflictIcon", "🚨"), currentIcon: localConfig.UString("currentIcon", "🔸"), diff --git a/modules/gcal/widget.go b/modules/gcal/widget.go index 53a68501..c7e1679e 100644 --- a/modules/gcal/widget.go +++ b/modules/gcal/widget.go @@ -20,7 +20,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Calendar", "gcal", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), app: app, ch: make(chan struct{}), diff --git a/modules/gerrit/settings.go b/modules/gerrit/settings.go index 91c9f423..dff7080a 100644 --- a/modules/gerrit/settings.go +++ b/modules/gerrit/settings.go @@ -14,6 +14,8 @@ type colors struct { } } +const configKey = "gerrit" + type Settings struct { colors common *cfg.Common @@ -25,11 +27,11 @@ type Settings struct { verifyServerCertificate bool } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.gerrit") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), domain: localConfig.UString("domain", ""), password: localConfig.UString("password", os.Getenv("WTF_GERRIT_PASSWORD")), diff --git a/modules/gerrit/widget.go b/modules/gerrit/widget.go index fa1ecb86..24c056f6 100644 --- a/modules/gerrit/widget.go +++ b/modules/gerrit/widget.go @@ -49,7 +49,7 @@ var ( func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Gerrit", "gerrit", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), Idx: 0, settings: settings, diff --git a/modules/git/settings.go b/modules/git/settings.go index d54a69a9..a99c85a1 100644 --- a/modules/git/settings.go +++ b/modules/git/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "git" + type Settings struct { common *cfg.Common @@ -14,11 +16,11 @@ type Settings struct { repositories []interface{} } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.git") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), commitCount: localConfig.UInt("commitCount", 10), commitFormat: localConfig.UString("commitFormat", "[forestgreen]%h [white]%s [grey]%an on %cd[white]"), diff --git a/modules/git/widget.go b/modules/git/widget.go index 9231ff55..d6ac7533 100644 --- a/modules/git/widget.go +++ b/modules/git/widget.go @@ -43,7 +43,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), MultiSourceWidget: wtf.NewMultiSourceWidget("git", "repository", "repositories"), - TextWidget: wtf.NewTextWidget(app, "Git", "git", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), app: app, pages: pages, diff --git a/modules/github/settings.go b/modules/github/settings.go index 14fd0ee1..dfe9bf96 100644 --- a/modules/github/settings.go +++ b/modules/github/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "github" + type Settings struct { common *cfg.Common @@ -18,11 +20,11 @@ type Settings struct { username string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.github") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_GITHUB_TOKEN")), baseURL: localConfig.UString("baseURL", os.Getenv("WTF_GITHUB_BASE_URL")), diff --git a/modules/github/widget.go b/modules/github/widget.go index 69e4f136..cd552c00 100644 --- a/modules/github/widget.go +++ b/modules/github/widget.go @@ -32,7 +32,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "GitHub", "github", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), Idx: 0, settings: settings, diff --git a/modules/gitlab/settings.go b/modules/gitlab/settings.go index 51ca388a..1db314da 100644 --- a/modules/gitlab/settings.go +++ b/modules/gitlab/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "gitlab" + type Settings struct { common *cfg.Common @@ -16,11 +18,11 @@ type Settings struct { username string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.gitlab") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_GITLAB_TOKEN")), domain: localConfig.UString("domain"), diff --git a/modules/gitlab/widget.go b/modules/gitlab/widget.go index a0d3f00f..04e1e860 100644 --- a/modules/gitlab/widget.go +++ b/modules/gitlab/widget.go @@ -39,7 +39,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Gitlab", "gitlab", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), Idx: 0, gitlab: gitlab, diff --git a/modules/gitter/settings.go b/modules/gitter/settings.go index 6abdefd7..6cb70eca 100644 --- a/modules/gitter/settings.go +++ b/modules/gitter/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "gitter" + type Settings struct { common *cfg.Common @@ -15,11 +17,11 @@ type Settings struct { roomURI string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.gitter") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiToken: localConfig.UString("apiToken", os.Getenv("WTF_GITTER_API_TOKEN")), numberOfMessages: localConfig.UInt("numberOfMessages", 10), diff --git a/modules/gitter/widget.go b/modules/gitter/widget.go index 80b54e95..8d0ff45a 100644 --- a/modules/gitter/widget.go +++ b/modules/gitter/widget.go @@ -32,7 +32,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Gitter", "gitter", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } diff --git a/modules/gspreadsheets/settings.go b/modules/gspreadsheets/settings.go index adea7b61..20f9ae4a 100644 --- a/modules/gspreadsheets/settings.go +++ b/modules/gspreadsheets/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "gspreadsheets" + type colors struct { values string } @@ -19,11 +21,11 @@ type Settings struct { sheetID string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.gspreadsheets") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), cellNames: localConfig.UList("cells.names"), secretFile: localConfig.UString("secretFile"), diff --git a/modules/gspreadsheets/widget.go b/modules/gspreadsheets/widget.go index 448b06f4..92d91b3a 100644 --- a/modules/gspreadsheets/widget.go +++ b/modules/gspreadsheets/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Google Spreadsheets", "gspreadsheets", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/hackernews/settings.go b/modules/hackernews/settings.go index 4a50cf4a..a0154493 100644 --- a/modules/hackernews/settings.go +++ b/modules/hackernews/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "hackernews" + type Settings struct { common *cfg.Common @@ -12,11 +14,11 @@ type Settings struct { storyType string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.hackernews") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), numberOfStories: localConfig.UInt("numberOfStories", 10), storyType: localConfig.UString("storyType", "top"), diff --git a/modules/hackernews/widget.go b/modules/hackernews/widget.go index 5c1f4bb5..5bdee3fe 100644 --- a/modules/hackernews/widget.go +++ b/modules/hackernews/widget.go @@ -38,7 +38,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Hacker News", "hackernews", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } diff --git a/modules/ipaddresses/ipapi/settings.go b/modules/ipaddresses/ipapi/settings.go index a78af00c..54ba0afc 100644 --- a/modules/ipaddresses/ipapi/settings.go +++ b/modules/ipaddresses/ipapi/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "ipapi" + type colors struct { name string value string @@ -15,11 +17,11 @@ type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.ipapi") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } settings.colors.name = localConfig.UString("colors.name", "red") diff --git a/modules/ipaddresses/ipapi/widget.go b/modules/ipaddresses/ipapi/widget.go index 53dec853..de4f00d1 100644 --- a/modules/ipaddresses/ipapi/widget.go +++ b/modules/ipaddresses/ipapi/widget.go @@ -38,7 +38,7 @@ type ipinfo struct { // NewWidget constructor func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "IPInfo", "ipapi", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/ipaddresses/ipinfo/settings.go b/modules/ipaddresses/ipinfo/settings.go index 445bc2ca..23ee349d 100644 --- a/modules/ipaddresses/ipinfo/settings.go +++ b/modules/ipaddresses/ipinfo/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "ipinfo" + type colors struct { name string value string @@ -15,11 +17,11 @@ type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.ipinfo") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } settings.colors.name = localConfig.UString("colors.name", "red") diff --git a/modules/ipaddresses/ipinfo/widget.go b/modules/ipaddresses/ipinfo/widget.go index 6d9135b6..bc8b44e8 100644 --- a/modules/ipaddresses/ipinfo/widget.go +++ b/modules/ipaddresses/ipinfo/widget.go @@ -31,7 +31,7 @@ type ipinfo struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "IPInfo", "ipinfo", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/jenkins/settings.go b/modules/jenkins/settings.go index 20f9c22c..c1ab8bf1 100644 --- a/modules/jenkins/settings.go +++ b/modules/jenkins/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "jenkins" + type Settings struct { common *cfg.Common @@ -17,11 +19,11 @@ type Settings struct { verifyServerCertificate bool } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.jenkins") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_JENKINS_API_KEY")), successBallColor: localConfig.UString("successBallColor", "blue"), diff --git a/modules/jenkins/widget.go b/modules/jenkins/widget.go index 51ec7b67..1b6e3d73 100644 --- a/modules/jenkins/widget.go +++ b/modules/jenkins/widget.go @@ -35,7 +35,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Jenkins", "jenkins", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } diff --git a/modules/jira/settings.go b/modules/jira/settings.go index a31c6f04..a55cc597 100644 --- a/modules/jira/settings.go +++ b/modules/jira/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "jira" + type colors struct { rows struct { even string @@ -27,11 +29,11 @@ type Settings struct { verifyServerCertificate bool } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.jira") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_JIRA_API_KEY")), domain: localConfig.UString("domain"), diff --git a/modules/jira/widget.go b/modules/jira/widget.go index 06c1b887..eb929530 100644 --- a/modules/jira/widget.go +++ b/modules/jira/widget.go @@ -34,7 +34,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Jira", "jira", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } diff --git a/modules/mercurial/settings.go b/modules/mercurial/settings.go index a8a48afb..b21f366e 100644 --- a/modules/mercurial/settings.go +++ b/modules/mercurial/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "mercurial" + type Settings struct { common *cfg.Common @@ -13,11 +15,11 @@ type Settings struct { repositories []interface{} } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.mercurial") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), commitCount: localConfig.UInt("commitCount", 10), commitFormat: localConfig.UString("commitFormat", "[forestgreen]{rev}:{phase} [white]{desc|firstline|strip} [grey]{author|person} {date|age}[white]"), diff --git a/modules/mercurial/widget.go b/modules/mercurial/widget.go index b42d780e..683eb939 100644 --- a/modules/mercurial/widget.go +++ b/modules/mercurial/widget.go @@ -37,8 +37,8 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - MultiSourceWidget: wtf.NewMultiSourceWidget("mercurial", "repository", "repositories"), - TextWidget: wtf.NewTextWidget(app, "Mercurial", "mercurial", true), + MultiSourceWidget: wtf.NewMultiSourceWidget(settings.common.ConfigKey, "repository", "repositories"), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), app: app, pages: pages, diff --git a/modules/nbascore/settings.go b/modules/nbascore/settings.go index 763135be..245c0ff0 100644 --- a/modules/nbascore/settings.go +++ b/modules/nbascore/settings.go @@ -5,13 +5,15 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "nbascore" + type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } return &settings diff --git a/modules/nbascore/widget.go b/modules/nbascore/widget.go index 0525c1a7..c1a28681 100644 --- a/modules/nbascore/widget.go +++ b/modules/nbascore/widget.go @@ -33,7 +33,7 @@ var offset = 0 func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "NBA Score", "nbascore", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } diff --git a/modules/newrelic/settings.go b/modules/newrelic/settings.go index 0971bf00..92a5eb54 100644 --- a/modules/newrelic/settings.go +++ b/modules/newrelic/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "newrelic" + type Settings struct { common *cfg.Common @@ -15,11 +17,11 @@ type Settings struct { deployCount int } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.newrelic") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_NEW_RELIC_API_KEY")), applicationID: localConfig.UInt("applicationID"), diff --git a/modules/newrelic/widget.go b/modules/newrelic/widget.go index 1ed7be12..7affdc38 100644 --- a/modules/newrelic/widget.go +++ b/modules/newrelic/widget.go @@ -17,7 +17,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "New Relic", "newrelic", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/opsgenie/settings.go b/modules/opsgenie/settings.go index 07ebc512..3da2c2e8 100644 --- a/modules/opsgenie/settings.go +++ b/modules/opsgenie/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "opsgenie" + type Settings struct { common *cfg.Common @@ -16,11 +18,11 @@ type Settings struct { scheduleIdentifierType string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.opsgenie") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_OPS_GENIE_API_KEY")), displayEmpty: localConfig.UBool("displayEmpty", true), diff --git a/modules/opsgenie/widget.go b/modules/opsgenie/widget.go index 26c051b8..a59652f9 100644 --- a/modules/opsgenie/widget.go +++ b/modules/opsgenie/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "OpsGenie", "opsgenie", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/pagerduty/settings.go b/modules/pagerduty/settings.go index 0e1ab511..473bc403 100644 --- a/modules/pagerduty/settings.go +++ b/modules/pagerduty/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "pagerduty" + type Settings struct { common *cfg.Common @@ -16,11 +18,11 @@ type Settings struct { showSchedules bool } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.pagerduty") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_PAGERDUTY_API_KEY")), escalationFilter: localConfig.UList("escalationFilter"), diff --git a/modules/pagerduty/widget.go b/modules/pagerduty/widget.go index d95201f8..a11cf8bb 100644 --- a/modules/pagerduty/widget.go +++ b/modules/pagerduty/widget.go @@ -17,7 +17,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "PagerDuty", "pagerduty", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/power/settings.go b/modules/power/settings.go index 8d03c2bf..bae89013 100644 --- a/modules/power/settings.go +++ b/modules/power/settings.go @@ -5,15 +5,17 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "power" + type Settings struct { common *cfg.Common filePath string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } return &settings diff --git a/modules/power/widget.go b/modules/power/widget.go index 97891b1d..fe5766b7 100644 --- a/modules/power/widget.go +++ b/modules/power/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Power", "power", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), Battery: NewBattery(), settings: settings, diff --git a/modules/resourceusage/settings.go b/modules/resourceusage/settings.go index 1910666d..d5f4ae29 100644 --- a/modules/resourceusage/settings.go +++ b/modules/resourceusage/settings.go @@ -5,13 +5,15 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "resourceusage" + type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } return &settings diff --git a/modules/resourceusage/widget.go b/modules/resourceusage/widget.go index d1218f41..ed7d1a2f 100644 --- a/modules/resourceusage/widget.go +++ b/modules/resourceusage/widget.go @@ -24,7 +24,7 @@ type Widget struct { // NewWidget Make new instance of widget func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - BarGraph: wtf.NewBarGraph(app, "Resource Usage", "resourceusage", false), + BarGraph: wtf.NewBarGraph(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/rollbar/settings.go b/modules/rollbar/settings.go index ac870b1d..7f24774d 100644 --- a/modules/rollbar/settings.go +++ b/modules/rollbar/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "rollbar" + type Settings struct { common *cfg.Common @@ -16,11 +18,11 @@ type Settings struct { projectOwner string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.rollbar") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), accessToken: localConfig.UString("accessToken"), activeOnly: localConfig.UBool("activeOnly", false), diff --git a/modules/rollbar/widget.go b/modules/rollbar/widget.go index 04c6d250..74fadc80 100644 --- a/modules/rollbar/widget.go +++ b/modules/rollbar/widget.go @@ -35,7 +35,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Rollbar", "rollbar", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } diff --git a/modules/security/settings.go b/modules/security/settings.go index b8c05c90..45e86f4f 100644 --- a/modules/security/settings.go +++ b/modules/security/settings.go @@ -5,13 +5,15 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "security" + type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } return &settings diff --git a/modules/security/widget.go b/modules/security/widget.go index e8e5fed9..68856bbc 100644 --- a/modules/security/widget.go +++ b/modules/security/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Security", "security", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/spotify/settings.go b/modules/spotify/settings.go index fe81ff57..50ed6be5 100644 --- a/modules/spotify/settings.go +++ b/modules/spotify/settings.go @@ -5,13 +5,15 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "spotify" + type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } return &settings diff --git a/modules/spotify/widget.go b/modules/spotify/widget.go index 98c4668b..5e35bfa8 100644 --- a/modules/spotify/widget.go +++ b/modules/spotify/widget.go @@ -30,7 +30,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * spotifyClient := spotigopher.NewClient() widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Spotify", "spotify", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), Info: spotigopher.Info{}, SpotifyClient: spotifyClient, diff --git a/modules/spotifyweb/settings.go b/modules/spotifyweb/settings.go index ffe6421d..63b0539a 100644 --- a/modules/spotifyweb/settings.go +++ b/modules/spotifyweb/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "spotifyweb" + type Settings struct { common *cfg.Common @@ -15,11 +17,11 @@ type Settings struct { secretKey string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.spotifyweb") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), callbackPort: localConfig.UString("callbackPort", "8080"), clientID: localConfig.UString("clientID", os.Getenv("SPOTIFY_ID")), diff --git a/modules/spotifyweb/widget.go b/modules/spotifyweb/widget.go index 98af1863..3d0ec40d 100644 --- a/modules/spotifyweb/widget.go +++ b/modules/spotifyweb/widget.go @@ -93,7 +93,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "SpotifyWeb", "spotifyweb", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), Info: Info{}, client: client, diff --git a/modules/status/settings.go b/modules/status/settings.go index b320f12b..9083f5b2 100644 --- a/modules/status/settings.go +++ b/modules/status/settings.go @@ -5,13 +5,15 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "status" + type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } return &settings diff --git a/modules/status/widget.go b/modules/status/widget.go index 81f256d2..257480a9 100644 --- a/modules/status/widget.go +++ b/modules/status/widget.go @@ -14,7 +14,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Status", "status", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), CurrentIcon: 0, settings: settings, diff --git a/modules/system/settings.go b/modules/system/settings.go index 67662fea..c748a0b2 100644 --- a/modules/system/settings.go +++ b/modules/system/settings.go @@ -5,13 +5,15 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "system" + type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } return &settings diff --git a/modules/system/widget.go b/modules/system/widget.go index e5bb08a4..2f5ee3e5 100644 --- a/modules/system/widget.go +++ b/modules/system/widget.go @@ -19,7 +19,7 @@ type Widget struct { func NewWidget(app *tview.Application, date, version string, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "System", "system", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), Date: date, settings: settings, diff --git a/modules/textfile/settings.go b/modules/textfile/settings.go index b0681aa1..ee692249 100644 --- a/modules/textfile/settings.go +++ b/modules/textfile/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "textfile" + type Settings struct { common *cfg.Common @@ -13,11 +15,11 @@ type Settings struct { formatStyle string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.textfile") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), filePaths: localConfig.UList("filePaths"), format: localConfig.UBool("format", false), diff --git a/modules/textfile/widget.go b/modules/textfile/widget.go index 8ead3508..36f7a39e 100644 --- a/modules/textfile/widget.go +++ b/modules/textfile/widget.go @@ -41,8 +41,8 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - MultiSourceWidget: wtf.NewMultiSourceWidget("textfile", "filePath", "filePaths"), - TextWidget: wtf.NewTextWidget(app, "TextFile", "textfile", true), + MultiSourceWidget: wtf.NewMultiSourceWidget(settings.common.ConfigKey, "filePath", "filePaths"), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } diff --git a/modules/todo/settings.go b/modules/todo/settings.go index 98f4a0f7..1cf6eeb4 100644 --- a/modules/todo/settings.go +++ b/modules/todo/settings.go @@ -5,17 +5,19 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "todo" + type Settings struct { common *cfg.Common filePath string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.todo") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), filePath: localConfig.UString("filename"), } diff --git a/modules/todo/widget.go b/modules/todo/widget.go index f742b5eb..de054813 100644 --- a/modules/todo/widget.go +++ b/modules/todo/widget.go @@ -49,7 +49,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Todo", "todo", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), app: app, settings: settings, diff --git a/modules/todoist/settings.go b/modules/todoist/settings.go index 912d13cc..54979d11 100644 --- a/modules/todoist/settings.go +++ b/modules/todoist/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "todoist" + type Settings struct { common *cfg.Common @@ -14,11 +16,11 @@ type Settings struct { projects []interface{} } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.todoist") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_TODOIST_TOKEN")), projects: localConfig.UList("projects"), diff --git a/modules/todoist/widget.go b/modules/todoist/widget.go index 5d037695..23118c6b 100644 --- a/modules/todoist/widget.go +++ b/modules/todoist/widget.go @@ -37,7 +37,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Todoist", "todoist", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } diff --git a/modules/travisci/settings.go b/modules/travisci/settings.go index dd16d7b5..b9660748 100644 --- a/modules/travisci/settings.go +++ b/modules/travisci/settings.go @@ -7,18 +7,20 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "travisci" + type Settings struct { - Common *cfg.Common + common *cfg.Common apiKey string pro bool } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.travisci") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - Common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_TRAVIS_API_TOKEN")), pro: localConfig.UBool("pro", false), diff --git a/modules/travisci/widget.go b/modules/travisci/widget.go index 151b9708..de948a09 100644 --- a/modules/travisci/widget.go +++ b/modules/travisci/widget.go @@ -34,7 +34,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "TravisCI", "travisci", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } diff --git a/modules/trello/settings.go b/modules/trello/settings.go index c02bcf5d..f7c39df4 100644 --- a/modules/trello/settings.go +++ b/modules/trello/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "trello" + type Settings struct { common *cfg.Common @@ -17,11 +19,11 @@ type Settings struct { username string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.trello") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), accessToken: localConfig.UString("accessToken", os.Getenv("WTF_TRELLO_ACCESS_TOKEN")), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_TRELLO_APP_KEY")), diff --git a/modules/trello/widget.go b/modules/trello/widget.go index 8ba8c89e..2c5a6f19 100644 --- a/modules/trello/widget.go +++ b/modules/trello/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Trello", "trello", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/twitter/settings.go b/modules/twitter/settings.go index 7b139d6e..487fdb30 100644 --- a/modules/twitter/settings.go +++ b/modules/twitter/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "twitter" + type Settings struct { common *cfg.Common @@ -15,11 +17,11 @@ type Settings struct { screenNames []interface{} } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.twitter") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), bearerToken: localConfig.UString("bearerToken", os.Getenv("WTF_TWITTER_BEARER_TOKEN")), count: localConfig.UInt("count", 5), diff --git a/modules/twitter/widget.go b/modules/twitter/widget.go index f7dad81f..874a0815 100644 --- a/modules/twitter/widget.go +++ b/modules/twitter/widget.go @@ -36,8 +36,8 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - MultiSourceWidget: wtf.NewMultiSourceWidget("twitter", "screenName", "screenNames"), - TextWidget: wtf.NewTextWidget(app, "Twitter", "twitter", true), + MultiSourceWidget: wtf.NewMultiSourceWidget(settings.common.ConfigKey, "screenName", "screenNames"), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), idx: 0, settings: settings, diff --git a/modules/unknown/settings.go b/modules/unknown/settings.go index a6530cdc..20a53e6c 100644 --- a/modules/unknown/settings.go +++ b/modules/unknown/settings.go @@ -5,13 +5,15 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "unkown" + type Settings struct { common *cfg.Common } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } return &settings diff --git a/modules/victorops/settings.go b/modules/victorops/settings.go index ba4c106c..07cdb864 100644 --- a/modules/victorops/settings.go +++ b/modules/victorops/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "victorops" + type Settings struct { common *cfg.Common @@ -15,11 +17,11 @@ type Settings struct { team string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.victorops") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiID: localConfig.UString("apiID", os.Getenv("WTF_VICTOROPS_API_ID")), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_VICTOROPS_API_KEY")), diff --git a/modules/victorops/widget.go b/modules/victorops/widget.go index 24a49a52..81eb37ba 100644 --- a/modules/victorops/widget.go +++ b/modules/victorops/widget.go @@ -27,7 +27,7 @@ type Widget struct { // NewWidget creates a new widget func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "VictorOps - OnCall", "victorops", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), } widget.View.SetScrollable(true) diff --git a/modules/weatherservices/prettyweather/settings.go b/modules/weatherservices/prettyweather/settings.go index 24fe08b7..55e99818 100644 --- a/modules/weatherservices/prettyweather/settings.go +++ b/modules/weatherservices/prettyweather/settings.go @@ -5,6 +5,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "prettyweather" + type Settings struct { common *cfg.Common @@ -14,11 +16,11 @@ type Settings struct { language string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.prettyweather") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), city: localConfig.UString("city", "Barcelona"), language: localConfig.UString("language", "en"), diff --git a/modules/weatherservices/prettyweather/widget.go b/modules/weatherservices/prettyweather/widget.go index 6faee73d..43c49485 100644 --- a/modules/weatherservices/prettyweather/widget.go +++ b/modules/weatherservices/prettyweather/widget.go @@ -18,7 +18,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Pretty Weather", "prettyweather", false), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), settings: settings, } diff --git a/modules/weatherservices/weather/settings.go b/modules/weatherservices/weather/settings.go index 1f52db16..e35b5480 100644 --- a/modules/weatherservices/weather/settings.go +++ b/modules/weatherservices/weather/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "weather" + type colors struct { current string } @@ -21,11 +23,11 @@ type Settings struct { tempUnit string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.weather") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("WTF_OWM_API_KEY")), cityIDs: localConfig.UList("cityids"), diff --git a/modules/weatherservices/weather/widget.go b/modules/weatherservices/weather/widget.go index 13bcb5ed..60b38379 100644 --- a/modules/weatherservices/weather/widget.go +++ b/modules/weatherservices/weather/widget.go @@ -33,7 +33,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, "Weather", "weather", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), Idx: 0, settings: settings, diff --git a/modules/zendesk/settings.go b/modules/zendesk/settings.go index 9bc1a407..f70fe09f 100644 --- a/modules/zendesk/settings.go +++ b/modules/zendesk/settings.go @@ -7,6 +7,8 @@ import ( "github.com/wtfutil/wtf/cfg" ) +const configKey = "zendesk" + type Settings struct { common *cfg.Common @@ -16,11 +18,11 @@ type Settings struct { username string } -func NewSettingsFromYAML(ymlConfig *config.Config) *Settings { - localConfig, _ := ymlConfig.Get("wtf.mods.zendesk") +func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { + localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(ymlConfig), + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), apiKey: localConfig.UString("apiKey", os.Getenv("ZENDESK_API")), status: localConfig.UString("status"), diff --git a/modules/zendesk/widget.go b/modules/zendesk/widget.go index eb00b0c6..6a282a4d 100644 --- a/modules/zendesk/widget.go +++ b/modules/zendesk/widget.go @@ -19,7 +19,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Zendesk", "zendesk", true), + TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), settings: settings, } From f09d08bda2ba900e82bb0a12f4df69aff1e9ad09 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Thu, 18 Apr 2019 18:05:56 -0700 Subject: [PATCH 51/60] WTF-400 Common settings implemented --- cfg/common_settings.go | 35 ++++++-- cfg/config_files.go | 52 ++++++++++-- logger/log.go | 2 +- main.go | 22 ++--- modules/bamboohr/widget.go | 2 +- modules/circleci/widget.go | 2 +- modules/clocks/widget.go | 2 +- modules/cmdrunner/widget.go | 2 +- modules/cryptoexchanges/bittrex/widget.go | 2 +- modules/cryptoexchanges/blockfolio/widget.go | 2 +- modules/cryptoexchanges/cryptolive/widget.go | 2 +- modules/datadog/widget.go | 2 +- modules/gcal/widget.go | 2 +- modules/gerrit/widget.go | 2 +- modules/git/widget.go | 4 +- modules/github/widget.go | 2 +- modules/gitlab/widget.go | 2 +- modules/gitter/widget.go | 2 +- modules/gspreadsheets/widget.go | 2 +- modules/hackernews/widget.go | 2 +- modules/ipaddresses/ipapi/widget.go | 2 +- modules/ipaddresses/ipinfo/widget.go | 2 +- modules/jenkins/widget.go | 2 +- modules/jira/widget.go | 2 +- modules/mercurial/widget.go | 2 +- modules/nbascore/widget.go | 2 +- modules/newrelic/widget.go | 2 +- modules/opsgenie/widget.go | 2 +- modules/pagerduty/widget.go | 2 +- modules/power/widget.go | 2 +- modules/rollbar/widget.go | 2 +- modules/security/widget.go | 2 +- modules/spotify/widget.go | 6 +- modules/spotifyweb/widget.go | 5 +- modules/status/widget.go | 2 +- modules/system/widget.go | 2 +- modules/textfile/widget.go | 10 +-- modules/todo/widget.go | 2 +- modules/todoist/widget.go | 2 +- modules/travisci/widget.go | 2 +- modules/trello/widget.go | 2 +- modules/twitter/widget.go | 2 +- modules/unknown/widget.go | 2 +- modules/victorops/widget.go | 2 +- .../weatherservices/prettyweather/widget.go | 2 +- modules/weatherservices/weather/widget.go | 2 +- modules/zendesk/widget.go | 2 +- wtf/text_widget.go | 84 ++++++++----------- wtf/utils.go | 3 +- wtf/widget_validator.go | 21 +++++ wtf/wtfable.go | 8 +- wtf_tests/colors_test.go | 2 +- 52 files changed, 201 insertions(+), 131 deletions(-) create mode 100644 wtf/widget_validator.go diff --git a/cfg/common_settings.go b/cfg/common_settings.go index 2bc4450f..a8d85191 100644 --- a/cfg/common_settings.go +++ b/cfg/common_settings.go @@ -13,6 +13,7 @@ type Colors struct { HighlightFore string HighlightBack string Text string + Title string } type Module struct { @@ -33,21 +34,27 @@ type Common struct { Position Enabled bool + FocusChar int RefreshInterval int Title string } func NewCommonSettingsFromYAML(name, configKey string, ymlConfig *config.Config) *Common { + colorsPath := "wtf.colors" + modulePath := "wtf.mods." + configKey + positionPath := "wtf.mods." + configKey + ".position" + common := Common{ Colors: Colors{ - Background: ymlConfig.UString("wtf.colors.background", "black"), - BorderFocusable: ymlConfig.UString("wtf.colors.border.focusable"), - BorderFocused: ymlConfig.UString("wtf.colors.border.focused"), - BorderNormal: ymlConfig.UString("wtf.colors.border.normal"), - Checked: ymlConfig.UString("wtf.colors.checked"), - HighlightFore: ymlConfig.UString("wtf.colors.highlight.fore"), - HighlightBack: ymlConfig.UString("wtf.colors.highlight.back"), - Text: ymlConfig.UString("wtf.colors.text", "white"), + Background: ymlConfig.UString(modulePath+".colors.background", ymlConfig.UString(colorsPath+".background", "black")), + BorderFocusable: ymlConfig.UString(colorsPath+".border.focusable", "red"), + BorderFocused: ymlConfig.UString(colorsPath+".border.focused", "orange"), + BorderNormal: ymlConfig.UString(colorsPath+".border.normal", "gray"), + Checked: ymlConfig.UString(colorsPath+".checked", "gray"), + HighlightFore: ymlConfig.UString(colorsPath+".highlight.fore", "black"), + HighlightBack: ymlConfig.UString(colorsPath+".highlight.back", "green"), + Text: ymlConfig.UString(modulePath+".colors.text", ymlConfig.UString(colorsPath+".text", "white")), + Title: ymlConfig.UString(modulePath+".colors.title", ymlConfig.UString(colorsPath+".title", "white")), }, Module: Module{ @@ -55,7 +62,17 @@ func NewCommonSettingsFromYAML(name, configKey string, ymlConfig *config.Config) Name: name, }, - Position: Position{}, + Position: Position{ + Height: ymlConfig.UInt(positionPath + ".height"), + Left: ymlConfig.UInt(positionPath + ".left"), + Top: ymlConfig.UInt(positionPath + ".top"), + Width: ymlConfig.UInt(positionPath + ".width"), + }, + + Enabled: ymlConfig.UBool(modulePath+".enabled", false), + FocusChar: ymlConfig.UInt(modulePath+".focusChar", -1), + RefreshInterval: ymlConfig.UInt(modulePath+".refreshInterval", 300), + Title: ymlConfig.UString(modulePath+".title", name), } return &common diff --git a/cfg/config_files.go b/cfg/config_files.go index 852ecf25..4bb00582 100644 --- a/cfg/config_files.go +++ b/cfg/config_files.go @@ -1,12 +1,14 @@ package cfg import ( + "errors" "fmt" "io/ioutil" "os" + "os/user" + "path/filepath" "github.com/olebedev/config" - "github.com/wtfutil/wtf/wtf" ) // ConfigDirV1 defines the path to the first version of configuration. Do not use this @@ -20,8 +22,8 @@ const ConfigDirV2 = "~/.config/wtf/" // MigrateOldConfig copies any existing configuration from the old location // to the new, XDG-compatible location func MigrateOldConfig() { - srcDir, _ := wtf.ExpandHomeDir(ConfigDirV1) - destDir, _ := wtf.ExpandHomeDir(ConfigDirV2) + srcDir, _ := expandHomeDir(ConfigDirV1) + destDir, _ := expandHomeDir(ConfigDirV2) // If the old config directory doesn't exist, do not move if _, err := os.Stat(srcDir); os.IsNotExist(err) { @@ -52,7 +54,7 @@ func MigrateOldConfig() { // ConfigDir returns the absolute path to the configuration directory func ConfigDir() (string, error) { - configDir, err := wtf.ExpandHomeDir(ConfigDirV2) + configDir, err := expandHomeDir(ConfigDirV2) if err != nil { return "", err } @@ -120,7 +122,7 @@ func CreateFile(fileName string) (string, error) { // LoadConfigFile loads the config.yml file to configure the app func LoadConfigFile(filePath string) *config.Config { - absPath, _ := wtf.ExpandHomeDir(filePath) + absPath, _ := expandHomeDir(filePath) cfg, err := config.ParseYamlFile(absPath) if err != nil { @@ -196,3 +198,43 @@ const simpleConfig = `wtf: width: 1 refreshInterval: 30 ` + +/* -------------------- Unexported Functions -------------------- */ + +// Expand expands the path to include the home directory if the path +// is prefixed with `~`. If it isn't prefixed with `~`, the path is +// returned as-is. +func expandHomeDir(path string) (string, error) { + if len(path) == 0 { + return path, nil + } + + if path[0] != '~' { + return path, nil + } + + if len(path) > 1 && path[1] != '/' && path[1] != '\\' { + return "", errors.New("cannot expand user-specific home dir") + } + + dir, err := home() + if err != nil { + return "", err + } + + return filepath.Join(dir, path[1:]), nil +} + +// Dir returns the home directory for the executing user. +// An error is returned if a home directory cannot be detected. +func home() (string, error) { + currentUser, err := user.Current() + if err != nil { + return "", err + } + if currentUser.HomeDir == "" { + return "", errors.New("cannot find user-specific home dir") + } + + return currentUser.HomeDir, nil +} diff --git a/logger/log.go b/logger/log.go index b786e122..7b4b88cd 100644 --- a/logger/log.go +++ b/logger/log.go @@ -22,7 +22,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, "Logs", "logger", true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), filePath: logFilePath(), settings: settings, diff --git a/main.go b/main.go index 1afc6ca1..be978e2a 100644 --- a/main.go +++ b/main.go @@ -151,7 +151,7 @@ func watchForConfigChanges(app *tview.Application, configFilePath string, grid * loadConfigFile(absPath) widgets := makeWidgets(app, pages) - validateWidgets(widgets) + wtf.ValidateWidgets(widgets) initializeFocusTracker(app, widgets) @@ -342,15 +342,15 @@ func makeWidgets(app *tview.Application, pages *tview.Pages) []wtf.Wtfable { return widgets } -// Check that all the loaded widgets are valid for display -func validateWidgets(widgets []wtf.Wtfable) { - for _, widget := range widgets { - if widget.Enabled() && !widget.IsPositionable() { - errStr := fmt.Sprintf("Widget config has invalid values: %s", widget.Key()) - log.Fatalln(errStr) - } - } -} +// // Check that all the loaded widgets are valid for display +// func validateWidgets(widgets []wtf.Wtfable) { +// for _, widget := range widgets { +// if widget.Enabled() && !widget.IsPositionable() { +// errStr := fmt.Sprintf("Widget config has invalid values: %s", widget.Key()) +// log.Fatalln(errStr) +// } +// } +// } /* -------------------- Main -------------------- */ @@ -376,7 +376,7 @@ func main() { pages := tview.NewPages() widgets := makeWidgets(app, pages) - validateWidgets(widgets) + wtf.ValidateWidgets(widgets) initializeFocusTracker(app, widgets) diff --git a/modules/bamboohr/widget.go b/modules/bamboohr/widget.go index 3a37cc77..c132a719 100644 --- a/modules/bamboohr/widget.go +++ b/modules/bamboohr/widget.go @@ -17,7 +17,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/circleci/widget.go b/modules/circleci/widget.go index 0c654241..4016a25e 100644 --- a/modules/circleci/widget.go +++ b/modules/circleci/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), Client: NewClient(settings.apiKey), settings: settings, diff --git a/modules/clocks/widget.go b/modules/clocks/widget.go index 45ffb3d7..e65cb584 100644 --- a/modules/clocks/widget.go +++ b/modules/clocks/widget.go @@ -19,7 +19,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, dateFormat: settings.dateFormat, diff --git a/modules/cmdrunner/widget.go b/modules/cmdrunner/widget.go index ec613969..bb326677 100644 --- a/modules/cmdrunner/widget.go +++ b/modules/cmdrunner/widget.go @@ -20,7 +20,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), args: settings.args, cmd: settings.cmd, diff --git a/modules/cryptoexchanges/bittrex/widget.go b/modules/cryptoexchanges/bittrex/widget.go index 70daaac7..9085626d 100644 --- a/modules/cryptoexchanges/bittrex/widget.go +++ b/modules/cryptoexchanges/bittrex/widget.go @@ -27,7 +27,7 @@ type Widget struct { // NewWidget Make new instance of widget func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, summaryList: summaryList{}, diff --git a/modules/cryptoexchanges/blockfolio/widget.go b/modules/cryptoexchanges/blockfolio/widget.go index 9453da57..27f8e5fe 100644 --- a/modules/cryptoexchanges/blockfolio/widget.go +++ b/modules/cryptoexchanges/blockfolio/widget.go @@ -20,7 +20,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), device_token: settings.deviceToken, settings: settings, diff --git a/modules/cryptoexchanges/cryptolive/widget.go b/modules/cryptoexchanges/cryptolive/widget.go index 39d2f14c..c16c4dcf 100644 --- a/modules/cryptoexchanges/cryptolive/widget.go +++ b/modules/cryptoexchanges/cryptolive/widget.go @@ -22,7 +22,7 @@ type Widget struct { // NewWidget Make new instance of widget func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), priceWidget: price.NewWidget(settings.priceSettings), toplistWidget: toplist.NewWidget(settings.toplistSettings), diff --git a/modules/datadog/widget.go b/modules/datadog/widget.go index 275ec1fc..7b97b40d 100644 --- a/modules/datadog/widget.go +++ b/modules/datadog/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/gcal/widget.go b/modules/gcal/widget.go index c7e1679e..ecc40cd7 100644 --- a/modules/gcal/widget.go +++ b/modules/gcal/widget.go @@ -20,7 +20,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), app: app, ch: make(chan struct{}), diff --git a/modules/gerrit/widget.go b/modules/gerrit/widget.go index 24c056f6..15afa32c 100644 --- a/modules/gerrit/widget.go +++ b/modules/gerrit/widget.go @@ -49,7 +49,7 @@ var ( func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), Idx: 0, settings: settings, diff --git a/modules/git/widget.go b/modules/git/widget.go index d6ac7533..f63952c7 100644 --- a/modules/git/widget.go +++ b/modules/git/widget.go @@ -42,8 +42,8 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - MultiSourceWidget: wtf.NewMultiSourceWidget("git", "repository", "repositories"), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + MultiSourceWidget: wtf.NewMultiSourceWidget(settings.common.ConfigKey, "repository", "repositories"), + TextWidget: wtf.NewTextWidget(app, settings.common, true), app: app, pages: pages, diff --git a/modules/github/widget.go b/modules/github/widget.go index cd552c00..8021183b 100644 --- a/modules/github/widget.go +++ b/modules/github/widget.go @@ -32,7 +32,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), Idx: 0, settings: settings, diff --git a/modules/gitlab/widget.go b/modules/gitlab/widget.go index 04e1e860..bbeb8f4e 100644 --- a/modules/gitlab/widget.go +++ b/modules/gitlab/widget.go @@ -39,7 +39,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), Idx: 0, gitlab: gitlab, diff --git a/modules/gitter/widget.go b/modules/gitter/widget.go index 8d0ff45a..3411e67f 100644 --- a/modules/gitter/widget.go +++ b/modules/gitter/widget.go @@ -32,7 +32,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } diff --git a/modules/gspreadsheets/widget.go b/modules/gspreadsheets/widget.go index 92d91b3a..f723cec0 100644 --- a/modules/gspreadsheets/widget.go +++ b/modules/gspreadsheets/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/hackernews/widget.go b/modules/hackernews/widget.go index 5bdee3fe..d9798d25 100644 --- a/modules/hackernews/widget.go +++ b/modules/hackernews/widget.go @@ -38,7 +38,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } diff --git a/modules/ipaddresses/ipapi/widget.go b/modules/ipaddresses/ipapi/widget.go index de4f00d1..24d6b1fd 100644 --- a/modules/ipaddresses/ipapi/widget.go +++ b/modules/ipaddresses/ipapi/widget.go @@ -38,7 +38,7 @@ type ipinfo struct { // NewWidget constructor func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/ipaddresses/ipinfo/widget.go b/modules/ipaddresses/ipinfo/widget.go index bc8b44e8..0f282519 100644 --- a/modules/ipaddresses/ipinfo/widget.go +++ b/modules/ipaddresses/ipinfo/widget.go @@ -31,7 +31,7 @@ type ipinfo struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/jenkins/widget.go b/modules/jenkins/widget.go index 64e6e022..145c397b 100644 --- a/modules/jenkins/widget.go +++ b/modules/jenkins/widget.go @@ -36,7 +36,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } diff --git a/modules/jira/widget.go b/modules/jira/widget.go index eb929530..91047552 100644 --- a/modules/jira/widget.go +++ b/modules/jira/widget.go @@ -34,7 +34,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } diff --git a/modules/mercurial/widget.go b/modules/mercurial/widget.go index 683eb939..cffe384b 100644 --- a/modules/mercurial/widget.go +++ b/modules/mercurial/widget.go @@ -38,7 +38,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), MultiSourceWidget: wtf.NewMultiSourceWidget(settings.common.ConfigKey, "repository", "repositories"), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), app: app, pages: pages, diff --git a/modules/nbascore/widget.go b/modules/nbascore/widget.go index c1a28681..d506fcee 100644 --- a/modules/nbascore/widget.go +++ b/modules/nbascore/widget.go @@ -33,7 +33,7 @@ var offset = 0 func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } diff --git a/modules/newrelic/widget.go b/modules/newrelic/widget.go index 7affdc38..73c24039 100644 --- a/modules/newrelic/widget.go +++ b/modules/newrelic/widget.go @@ -17,7 +17,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/opsgenie/widget.go b/modules/opsgenie/widget.go index a59652f9..d6d34b2a 100644 --- a/modules/opsgenie/widget.go +++ b/modules/opsgenie/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/pagerduty/widget.go b/modules/pagerduty/widget.go index a11cf8bb..4db3f72b 100644 --- a/modules/pagerduty/widget.go +++ b/modules/pagerduty/widget.go @@ -17,7 +17,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/power/widget.go b/modules/power/widget.go index fe5766b7..db25265e 100644 --- a/modules/power/widget.go +++ b/modules/power/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), Battery: NewBattery(), settings: settings, diff --git a/modules/rollbar/widget.go b/modules/rollbar/widget.go index 74fadc80..985b7079 100644 --- a/modules/rollbar/widget.go +++ b/modules/rollbar/widget.go @@ -35,7 +35,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } diff --git a/modules/security/widget.go b/modules/security/widget.go index 68856bbc..b656ab71 100644 --- a/modules/security/widget.go +++ b/modules/security/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/spotify/widget.go b/modules/spotify/widget.go index 5e35bfa8..b35c0838 100644 --- a/modules/spotify/widget.go +++ b/modules/spotify/widget.go @@ -30,14 +30,16 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * spotifyClient := spotigopher.NewClient() widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), Info: spotigopher.Info{}, SpotifyClient: spotifyClient, settings: settings, } + + widget.settings.common.RefreshInterval = 5 + widget.HelpfulWidget.SetView(widget.View) - widget.TextWidget.RefreshInt = 5 widget.View.SetInputCapture(widget.captureInput) widget.View.SetWrap(true) widget.View.SetWordWrap(true) diff --git a/modules/spotifyweb/widget.go b/modules/spotifyweb/widget.go index 3d0ec40d..fe91efde 100644 --- a/modules/spotifyweb/widget.go +++ b/modules/spotifyweb/widget.go @@ -93,7 +93,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), Info: Info{}, client: client, @@ -135,8 +135,9 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * // If inconvenient, I'll remove this option and save the URL in a file or some other method. wtf.OpenFile(`"` + authURL + `"`) + widget.settings.common.RefreshInterval = 5 + widget.HelpfulWidget.SetView(widget.View) - widget.TextWidget.RefreshInt = 5 widget.View.SetInputCapture(widget.captureInput) widget.View.SetWrap(true) widget.View.SetWordWrap(true) diff --git a/modules/status/widget.go b/modules/status/widget.go index 257480a9..e9a07650 100644 --- a/modules/status/widget.go +++ b/modules/status/widget.go @@ -14,7 +14,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), CurrentIcon: 0, settings: settings, diff --git a/modules/system/widget.go b/modules/system/widget.go index 2f5ee3e5..4bf5b32d 100644 --- a/modules/system/widget.go +++ b/modules/system/widget.go @@ -19,7 +19,7 @@ type Widget struct { func NewWidget(app *tview.Application, date, version string, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), Date: date, settings: settings, diff --git a/modules/textfile/widget.go b/modules/textfile/widget.go index 36f7a39e..c0d01778 100644 --- a/modules/textfile/widget.go +++ b/modules/textfile/widget.go @@ -42,19 +42,17 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), MultiSourceWidget: wtf.NewMultiSourceWidget(settings.common.ConfigKey, "filePath", "filePaths"), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } // Don't use a timer for this widget, watch for filesystem changes instead - widget.RefreshInt = 0 - - widget.LoadSources() - widget.SetDisplayFunction(widget.display) + widget.settings.common.RefreshInterval = 0 widget.HelpfulWidget.SetView(widget.View) - + widget.LoadSources() + widget.SetDisplayFunction(widget.display) widget.View.SetWrap(true) widget.View.SetWordWrap(true) widget.View.SetInputCapture(widget.keyboardIntercept) diff --git a/modules/todo/widget.go b/modules/todo/widget.go index de054813..3af8558a 100644 --- a/modules/todo/widget.go +++ b/modules/todo/widget.go @@ -49,7 +49,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), app: app, settings: settings, diff --git a/modules/todoist/widget.go b/modules/todoist/widget.go index 23118c6b..0a57c22e 100644 --- a/modules/todoist/widget.go +++ b/modules/todoist/widget.go @@ -37,7 +37,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } diff --git a/modules/travisci/widget.go b/modules/travisci/widget.go index de948a09..1265c176 100644 --- a/modules/travisci/widget.go +++ b/modules/travisci/widget.go @@ -34,7 +34,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } diff --git a/modules/trello/widget.go b/modules/trello/widget.go index 2c5a6f19..fd79984f 100644 --- a/modules/trello/widget.go +++ b/modules/trello/widget.go @@ -16,7 +16,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/twitter/widget.go b/modules/twitter/widget.go index 874a0815..b2056932 100644 --- a/modules/twitter/widget.go +++ b/modules/twitter/widget.go @@ -37,7 +37,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), MultiSourceWidget: wtf.NewMultiSourceWidget(settings.common.ConfigKey, "screenName", "screenNames"), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), idx: 0, settings: settings, diff --git a/modules/unknown/widget.go b/modules/unknown/widget.go index 6be2c567..053c9bad 100644 --- a/modules/unknown/widget.go +++ b/modules/unknown/widget.go @@ -15,7 +15,7 @@ type Widget struct { func NewWidget(app *tview.Application, name string, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, name, name, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/victorops/widget.go b/modules/victorops/widget.go index 81eb37ba..a3e0fcdb 100644 --- a/modules/victorops/widget.go +++ b/modules/victorops/widget.go @@ -27,7 +27,7 @@ type Widget struct { // NewWidget creates a new widget func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), } widget.View.SetScrollable(true) diff --git a/modules/weatherservices/prettyweather/widget.go b/modules/weatherservices/prettyweather/widget.go index 43c49485..3107db35 100644 --- a/modules/weatherservices/prettyweather/widget.go +++ b/modules/weatherservices/prettyweather/widget.go @@ -18,7 +18,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, false), + TextWidget: wtf.NewTextWidget(app, settings.common, false), settings: settings, } diff --git a/modules/weatherservices/weather/widget.go b/modules/weatherservices/weather/widget.go index 60b38379..c4017b36 100644 --- a/modules/weatherservices/weather/widget.go +++ b/modules/weatherservices/weather/widget.go @@ -33,7 +33,7 @@ type Widget struct { func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) *Widget { widget := Widget{ HelpfulWidget: wtf.NewHelpfulWidget(app, pages, HelpText), - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), Idx: 0, settings: settings, diff --git a/modules/zendesk/widget.go b/modules/zendesk/widget.go index 6a282a4d..7ce1649d 100644 --- a/modules/zendesk/widget.go +++ b/modules/zendesk/widget.go @@ -19,7 +19,7 @@ type Widget struct { func NewWidget(app *tview.Application, settings *Settings) *Widget { widget := Widget{ - TextWidget: wtf.NewTextWidget(app, settings.common.Name, settings.common.ConfigKey, true), + TextWidget: wtf.NewTextWidget(app, settings.common, true), settings: settings, } diff --git a/wtf/text_widget.go b/wtf/text_widget.go index 74ead21f..fe1b35e4 100644 --- a/wtf/text_widget.go +++ b/wtf/text_widget.go @@ -5,44 +5,49 @@ import ( "github.com/olebedev/config" "github.com/rivo/tview" + "github.com/wtfutil/wtf/cfg" ) var Config *config.Config type TextWidget struct { - enabled bool - focusable bool - focusChar string - key string - name string + enabled bool + focusable bool + focusChar string + key string + name string + refreshInterval int - RefreshInt int - View *tview.TextView + View *tview.TextView + CommonSettings *cfg.Common Position } -func NewTextWidget(app *tview.Application, name string, configKey string, focusable bool) TextWidget { - focusCharValue := Config.UInt(fmt.Sprintf("wtf.mods.%s.focusChar", configKey), -1) - focusChar := string('0' + focusCharValue) - if focusCharValue == -1 { +func NewTextWidget(app *tview.Application, commonSettings *cfg.Common, focusable bool) TextWidget { + configKey := commonSettings.ConfigKey + + focusChar := string('0' + commonSettings.FocusChar) + if commonSettings.FocusChar == -1 { focusChar = "" } widget := TextWidget{ - enabled: Config.UBool(fmt.Sprintf("wtf.mods.%s.enabled", configKey), false), - focusable: focusable, - focusChar: focusChar, - key: configKey, - name: Config.UString(fmt.Sprintf("wtf.mods.%s.title", configKey), name), - RefreshInt: Config.UInt(fmt.Sprintf("wtf.mods.%s.refreshInterval", configKey)), + CommonSettings: commonSettings, + + enabled: commonSettings.Enabled, + focusable: focusable, + focusChar: focusChar, + key: commonSettings.ConfigKey, + name: commonSettings.Name, + refreshInterval: commonSettings.RefreshInterval, } widget.Position = NewPosition( - Config.UInt(fmt.Sprintf("wtf.mods.%s.position.top", configKey)), - Config.UInt(fmt.Sprintf("wtf.mods.%s.position.left", configKey)), - Config.UInt(fmt.Sprintf("wtf.mods.%s.position.width", configKey)), - Config.UInt(fmt.Sprintf("wtf.mods.%s.position.height", configKey)), + commonSettings.Position.Top, + commonSettings.Position.Left, + commonSettings.Position.Width, + commonSettings.Position.Height, ) widget.addView(app, configKey) @@ -54,10 +59,10 @@ func NewTextWidget(app *tview.Application, name string, configKey string, focusa func (widget *TextWidget) BorderColor() string { if widget.Focusable() { - return Config.UString("wtf.colors.border.focusable", "red") + return widget.CommonSettings.Colors.BorderFocusable } - return Config.UString("wtf.colors.border.normal", "gray") + return widget.CommonSettings.Colors.BorderNormal } func (widget *TextWidget) ContextualTitle(defaultStr string) string { @@ -103,7 +108,7 @@ func (widget *TextWidget) Name() string { } func (widget *TextWidget) RefreshInterval() int { - return widget.RefreshInt + return widget.refreshInterval } func (widget *TextWidget) SetFocusChar(char string) { @@ -119,34 +124,19 @@ func (widget *TextWidget) TextView() *tview.TextView { func (widget *TextWidget) addView(app *tview.Application, configKey string) { view := tview.NewTextView() - view.SetBackgroundColor(ColorFor( - Config.UString(fmt.Sprintf("wtf.mods.%s.colors.background", configKey), - Config.UString("wtf.colors.background", "black"), - ), - )) - - view.SetTextColor(ColorFor( - Config.UString( - fmt.Sprintf("wtf.mods.%s.colors.text", configKey), - Config.UString("wtf.colors.text", "white"), - ), - )) - - view.SetTitleColor(ColorFor( - Config.UString( - fmt.Sprintf("wtf.mods.%s.colors.title", configKey), - Config.UString("wtf.colors.title", "white"), - ), - )) + view.SetBackgroundColor(ColorFor(widget.CommonSettings.Colors.Background)) + view.SetBorderColor(ColorFor(widget.BorderColor())) + view.SetTextColor(ColorFor(widget.CommonSettings.Colors.Text)) + view.SetTitleColor(ColorFor(widget.CommonSettings.Colors.Title)) view.SetBorder(true) - view.SetBorderColor(ColorFor(widget.BorderColor())) - view.SetChangedFunc(func() { - app.Draw() - }) view.SetDynamicColors(true) view.SetTitle(widget.ContextualTitle(widget.name)) view.SetWrap(false) + view.SetChangedFunc(func() { + app.Draw() + }) + widget.View = view } diff --git a/wtf/utils.go b/wtf/utils.go index 205ea09a..2c1c1f88 100644 --- a/wtf/utils.go +++ b/wtf/utils.go @@ -5,9 +5,8 @@ import ( "io/ioutil" "os/exec" "regexp" - "strings" - //"sync" "runtime" + "strings" "github.com/rivo/tview" ) diff --git a/wtf/widget_validator.go b/wtf/widget_validator.go new file mode 100644 index 00000000..9483db28 --- /dev/null +++ b/wtf/widget_validator.go @@ -0,0 +1,21 @@ +package wtf + +import ( + "fmt" + "log" +) + +// Check that all the loaded widgets are valid for display +func ValidateWidgets(widgets []Wtfable) (bool, error) { + result := true + var err error + + for _, widget := range widgets { + if widget.Enabled() && !widget.IsPositionable() { + errStr := fmt.Sprintf("Widget config has invalid values: %s", widget.Key()) + log.Fatalln(errStr) + } + } + + return result, err +} diff --git a/wtf/wtfable.go b/wtf/wtfable.go index 86e33121..aad2b78c 100644 --- a/wtf/wtfable.go +++ b/wtf/wtfable.go @@ -9,15 +9,15 @@ type Wtfable interface { Scheduler BorderColor() string - Focusable() bool FocusChar() string + Focusable() bool Key() string Name() string SetFocusChar(string) TextView() *tview.TextView - Top() int - Left() int - Width() int Height() int + Left() int + Top() int + Width() int } diff --git a/wtf_tests/colors_test.go b/wtf_tests/colors_test.go index 8f7ddea6..baec66ac 100644 --- a/wtf_tests/colors_test.go +++ b/wtf_tests/colors_test.go @@ -7,7 +7,7 @@ import ( . "github.com/wtfutil/wtf/wtf" ) -func TestASCIItoTviewColors(t *testing.T) { +func Test_ASCIItoTviewColors(t *testing.T) { Equal(t, "", ASCIItoTviewColors("")) Equal(t, "cat", ASCIItoTviewColors("cat")) Equal(t, "[38;5;226mcat/[-]", ASCIItoTviewColors("[38;5;226mcat/")) From 59f0bc6cfcc97b12c116afcec6ec991566a5e4ef Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Thu, 18 Apr 2019 19:02:08 -0700 Subject: [PATCH 52/60] WTF-400 Partial conversion to new Common settings --- cfg/common_settings.go | 14 ++++++++- checklist/checklist.go | 62 +++++++++++++++++++++---------------- checklist/checklist_item.go | 25 ++++++++++----- modules/todo/display.go | 15 +++++---- modules/todo/widget.go | 2 +- modules/todoist/display.go | 6 ++-- modules/zendesk/widget.go | 10 +++--- wtf/text_widget.go | 4 +++ 8 files changed, 89 insertions(+), 49 deletions(-) diff --git a/cfg/common_settings.go b/cfg/common_settings.go index a8d85191..8d7a8c39 100644 --- a/cfg/common_settings.go +++ b/cfg/common_settings.go @@ -28,10 +28,16 @@ type Position struct { Width int } +type Sigils struct { + CheckedIcon string + UncheckedIcon string +} + type Common struct { Colors Module Position + Sigils Enabled bool FocusChar int @@ -43,6 +49,7 @@ func NewCommonSettingsFromYAML(name, configKey string, ymlConfig *config.Config) colorsPath := "wtf.colors" modulePath := "wtf.mods." + configKey positionPath := "wtf.mods." + configKey + ".position" + sigilsPath := "wtf.sigils" common := Common{ Colors: Colors{ @@ -50,7 +57,7 @@ func NewCommonSettingsFromYAML(name, configKey string, ymlConfig *config.Config) BorderFocusable: ymlConfig.UString(colorsPath+".border.focusable", "red"), BorderFocused: ymlConfig.UString(colorsPath+".border.focused", "orange"), BorderNormal: ymlConfig.UString(colorsPath+".border.normal", "gray"), - Checked: ymlConfig.UString(colorsPath+".checked", "gray"), + Checked: ymlConfig.UString(colorsPath+".checked", "white"), HighlightFore: ymlConfig.UString(colorsPath+".highlight.fore", "black"), HighlightBack: ymlConfig.UString(colorsPath+".highlight.back", "green"), Text: ymlConfig.UString(modulePath+".colors.text", ymlConfig.UString(colorsPath+".text", "white")), @@ -69,6 +76,11 @@ func NewCommonSettingsFromYAML(name, configKey string, ymlConfig *config.Config) Width: ymlConfig.UInt(positionPath + ".width"), }, + Sigils: Sigils{ + CheckedIcon: ymlConfig.UString(sigilsPath+".checkedIcon", "x"), + UncheckedIcon: ymlConfig.UString(sigilsPath+".uncheckedIcon", " "), + }, + Enabled: ymlConfig.UBool(modulePath+".enabled", false), FocusChar: ymlConfig.UInt(modulePath+".focusChar", -1), RefreshInterval: ymlConfig.UInt(modulePath+".refreshInterval", 300), diff --git a/checklist/checklist.go b/checklist/checklist.go index af55b03c..7e293878 100644 --- a/checklist/checklist.go +++ b/checklist/checklist.go @@ -3,14 +3,18 @@ package checklist // Checklist is a module for creating generic checklist implementations // See 'Todo' for an implementation example type Checklist struct { - Selected int - Items []*ChecklistItem + + checkedIcon string + selected int + uncheckedIcon string } -func NewChecklist() Checklist { +func NewChecklist(checkedIcon, uncheckedIcon string) Checklist { list := Checklist{ - Selected: -1, + checkedIcon: checkedIcon, + selected: -1, + uncheckedIcon: uncheckedIcon, } return list @@ -20,12 +24,14 @@ func NewChecklist() Checklist { // Add creates a new item in the checklist func (list *Checklist) Add(checked bool, text string) { - item := ChecklistItem{ - Checked: checked, - Text: text, - } + item := NewChecklistItem( + checked, + text, + list.checkedIcon, + list.uncheckedIcon, + ) - list.Items = append([]*ChecklistItem{&item}, list.Items...) + list.Items = append([]*ChecklistItem{item}, list.Items...) } // CheckedItems returns a slice of all the checked items @@ -43,7 +49,7 @@ func (list *Checklist) CheckedItems() []*ChecklistItem { // Delete removes the selected item from the checklist func (list *Checklist) Delete() { - list.Items = append(list.Items[:list.Selected], list.Items[list.Selected+1:]...) + list.Items = append(list.Items[:list.selected], list.Items[list.selected+1:]...) list.Prev() } @@ -53,18 +59,18 @@ func (list *Checklist) Demote() { return } - j := list.Selected + 1 + j := list.selected + 1 if j >= len(list.Items) { j = 0 } - list.Swap(list.Selected, j) - list.Selected = j + list.Swap(list.selected, j) + list.selected = j } // IsSelectable returns true if the checklist has selectable items, false if it does not func (list *Checklist) IsSelectable() bool { - return list.Selected >= 0 && list.Selected < len(list.Items) + return list.selected >= 0 && list.selected < len(list.Items) } // IsUnselectable returns true if the checklist has no selectable items, false if it does @@ -74,9 +80,9 @@ func (list *Checklist) IsUnselectable() bool { // Next selects the next item in the checklist func (list *Checklist) Next() { - list.Selected = list.Selected + 1 - if list.Selected >= len(list.Items) { - list.Selected = 0 + list.selected = list.selected + 1 + if list.selected >= len(list.Items) { + list.selected = 0 } } @@ -95,9 +101,9 @@ func (list *Checklist) LongestLine() int { // Prev selects the previous item in the checklist func (list *Checklist) Prev() { - list.Selected = list.Selected - 1 - if list.Selected < 0 { - list.Selected = len(list.Items) - 1 + list.selected = list.selected - 1 + if list.selected < 0 { + list.selected = len(list.Items) - 1 } } @@ -107,13 +113,17 @@ func (list *Checklist) Promote() { return } - j := list.Selected - 1 + j := list.selected - 1 if j < 0 { j = len(list.Items) - 1 } - list.Swap(list.Selected, j) - list.Selected = j + list.Swap(list.selected, j) + list.selected = j +} + +func (list *Checklist) Selected() int { + return list.selected } // SelectedItem returns the currently-selected checklist item or nil if no item is selected @@ -122,13 +132,13 @@ func (list *Checklist) SelectedItem() *ChecklistItem { return nil } - return list.Items[list.Selected] + return list.Items[list.selected] } func (list *Checklist) SetSelectedByItem(selectableItem *ChecklistItem) { for idx, item := range list.Items { if item == selectableItem { - list.Selected = idx + list.selected = idx break } } @@ -158,7 +168,7 @@ func (list *Checklist) UncheckedItems() []*ChecklistItem { // Unselect removes the current select such that no item is selected func (list *Checklist) Unselect() { - list.Selected = -1 + list.selected = -1 } // Update sets the text of the currently-selected item to the provided text diff --git a/checklist/checklist_item.go b/checklist/checklist_item.go index 70d0ae6f..e574ba92 100644 --- a/checklist/checklist_item.go +++ b/checklist/checklist_item.go @@ -1,23 +1,34 @@ package checklist -import ( - "github.com/wtfutil/wtf/wtf" -) +import () // ChecklistItem is a module for creating generic checklist implementations // See 'Todo' for an implementation example type ChecklistItem struct { - Checked bool - Text string + Checked bool + CheckedIcon string + Text string + UncheckedIcon string +} + +func NewChecklistItem(checked bool, text string, checkedIcon, uncheckedIcon string) *ChecklistItem { + item := &ChecklistItem{ + Checked: checked, + CheckedIcon: checkedIcon, + Text: text, + UncheckedIcon: uncheckedIcon, + } + + return item } // CheckMark returns the string used to indicate a ChecklistItem is checked or unchecked func (item *ChecklistItem) CheckMark() string { if item.Checked { - return wtf.Config.UString("wtf.mods.todo.checkedIcon", "x") + return item.CheckedIcon } - return " " + return item.UncheckedIcon } // Toggle changes the checked state of the ChecklistItem diff --git a/modules/todo/display.go b/modules/todo/display.go index 684a9dee..2471438c 100644 --- a/modules/todo/display.go +++ b/modules/todo/display.go @@ -13,7 +13,10 @@ const checkWidth = 4 func (widget *Widget) display() { str := "" - newList := checklist.NewChecklist() + newList := checklist.NewChecklist( + widget.settings.common.Sigils.CheckedIcon, + widget.settings.common.Sigils.UncheckedIcon, + ) offset := 0 @@ -33,19 +36,19 @@ func (widget *Widget) display() { widget.View.Clear() widget.View.SetText(str) - widget.View.Highlight(strconv.Itoa(widget.list.Selected)).ScrollToHighlight() + widget.View.Highlight(strconv.Itoa(widget.list.Selected())).ScrollToHighlight() } func (widget *Widget) formattedItemLine(idx int, item *checklist.ChecklistItem, selectedItem *checklist.ChecklistItem, maxLen int) string { - foreColor, backColor := "white", wtf.Config.UString("wtf.colors.background", "black") + foreColor, backColor := widget.settings.common.Colors.Text, widget.settings.common.Colors.Background if item.Checked { - foreColor = wtf.Config.UString("wtf.colors.checked", "white") + foreColor = widget.settings.common.Colors.Checked } if widget.View.HasFocus() && (item == selectedItem) { - foreColor = wtf.Config.UString("wtf.colors.highlight.fore", "black") - backColor = wtf.Config.UString("wtf.colors.highlight.back", "orange") + foreColor = widget.settings.common.Colors.HighlightFore + backColor = widget.settings.common.Colors.HighlightBack } str := fmt.Sprintf( diff --git a/modules/todo/widget.go b/modules/todo/widget.go index 3af8558a..97c07cbd 100644 --- a/modules/todo/widget.go +++ b/modules/todo/widget.go @@ -54,7 +54,7 @@ func NewWidget(app *tview.Application, pages *tview.Pages, settings *Settings) * app: app, settings: settings, filePath: settings.filePath, - list: checklist.NewChecklist(), + list: checklist.NewChecklist(settings.common.Sigils.CheckedIcon, settings.common.Sigils.UncheckedIcon), pages: pages, } diff --git a/modules/todoist/display.go b/modules/todoist/display.go index c9071419..56c5be64 100644 --- a/modules/todoist/display.go +++ b/modules/todoist/display.go @@ -24,11 +24,11 @@ func (widget *Widget) display() { maxLen := proj.LongestLine() for index, item := range proj.tasks { - foreColor, backColor := "white", wtf.Config.UString("wtf.colors.background", "black") + foreColor, backColor := widget.settings.common.Colors.Text, widget.settings.common.Colors.Background if index == proj.index { - foreColor = wtf.Config.UString("wtf.colors.highlight.fore", "black") - backColor = wtf.Config.UString("wtf.colors.highlight.back", "orange") + foreColor = widget.settings.common.Colors.HighlightFore + backColor = widget.settings.common.Colors.HighlightBack } row := fmt.Sprintf( diff --git a/modules/zendesk/widget.go b/modules/zendesk/widget.go index 7ce1649d..11c06efa 100644 --- a/modules/zendesk/widget.go +++ b/modules/zendesk/widget.go @@ -63,13 +63,13 @@ func (widget *Widget) textContent(items []Ticket) string { } func (widget *Widget) format(ticket Ticket, idx int) string { - var str string - requesterName := widget.parseRequester(ticket) - textColor := wtf.Config.UString("wtf.colors.background", "green") + textColor := widget.settings.common.Colors.Background if idx == widget.selected { - textColor = wtf.Config.UString("wtf.colors.background", "orange") + textColor = widget.settings.common.Colors.BorderFocused } - str = fmt.Sprintf(" [%s:]%d - %s\n %s\n\n", textColor, ticket.Id, requesterName, ticket.Subject) + + requesterName := widget.parseRequester(ticket) + str := fmt.Sprintf(" [%s:]%d - %s\n %s\n\n", textColor, ticket.Id, requesterName, ticket.Subject) return str } diff --git a/wtf/text_widget.go b/wtf/text_widget.go index fe1b35e4..17ca9277 100644 --- a/wtf/text_widget.go +++ b/wtf/text_widget.go @@ -115,6 +115,10 @@ func (widget *TextWidget) SetFocusChar(char string) { widget.focusChar = char } +func (widget *TextWidget) String() string { + return widget.name +} + func (widget *TextWidget) TextView() *tview.TextView { return widget.View } From 643840e0da4400e8e0286a9c15bea1384d59df1a Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Fri, 19 Apr 2019 09:08:36 -0700 Subject: [PATCH 53/60] WTF-400 Checklist items now have dynamically-settable checkmark icons --- modules/todo/widget.go | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/modules/todo/widget.go b/modules/todo/widget.go index 97c07cbd..51367b38 100644 --- a/modules/todo/widget.go +++ b/modules/todo/widget.go @@ -193,7 +193,10 @@ func (widget *Widget) load() { filePath := fmt.Sprintf("%s/%s", confDir, widget.filePath) fileData, _ := wtf.ReadFileBytes(filePath) + yaml.Unmarshal(fileData, &widget.list) + + widget.setItemChecks() } func (widget *Widget) newItem() { @@ -227,6 +230,15 @@ func (widget *Widget) persist() { } } +// setItemChecks rolls through the checklist and ensures that all checklist +// items have the correct checked/unchecked icon per the user's preferences +func (widget *Widget) setItemChecks() { + for _, item := range widget.list.Items { + item.CheckedIcon = widget.settings.common.CheckedIcon + item.UncheckedIcon = widget.settings.common.UncheckedIcon + } +} + /* -------------------- Modal Form -------------------- */ func (widget *Widget) addButtons(form *tview.Form, saveFctn func()) { From b855b9bee26b217db73ed96c9d1784d3de6dc597 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Fri, 19 Apr 2019 09:14:09 -0700 Subject: [PATCH 54/60] .vscode dir into .gitignore --- .gitignore | 1 + .vscode/settings.json | 3 --- 2 files changed, 1 insertion(+), 3 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.gitignore b/.gitignore index 4135fa0b..8f9f6635 100644 --- a/.gitignore +++ b/.gitignore @@ -19,6 +19,7 @@ gcal/client_secret.json gspreadsheets/client_secret.json profile.pdf report.* +.vscode # All things node node_modules/ diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 56422821..00000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "workbench.colorCustomizations": {} -} \ No newline at end of file From 03e186a0cc3380f01282c05476494f23672a446b Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Fri, 19 Apr 2019 09:28:14 -0700 Subject: [PATCH 55/60] WTF-400 Make ChecklistItem tests pass again --- checklist/checklist_item.go | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/checklist/checklist_item.go b/checklist/checklist_item.go index e574ba92..40cfafb8 100644 --- a/checklist/checklist_item.go +++ b/checklist/checklist_item.go @@ -24,6 +24,8 @@ func NewChecklistItem(checked bool, text string, checkedIcon, uncheckedIcon stri // CheckMark returns the string used to indicate a ChecklistItem is checked or unchecked func (item *ChecklistItem) CheckMark() string { + item.ensureItemIcons() + if item.Checked { return item.CheckedIcon } @@ -36,3 +38,15 @@ func (item *ChecklistItem) CheckMark() string { func (item *ChecklistItem) Toggle() { item.Checked = !item.Checked } + +/* -------------------- Unexported Functions -------------------- */ + +func (item *ChecklistItem) ensureItemIcons() { + if item.CheckedIcon == "" { + item.CheckedIcon = "x" + } + + if item.UncheckedIcon == "" { + item.UncheckedIcon = " " + } +} From a8e360281753fbb14661da9ef501e01127c20234 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Fri, 19 Apr 2019 09:35:05 -0700 Subject: [PATCH 56/60] WTF-400 Fix title display in CmdRunner --- cfg/common_settings.go | 2 +- modules/cmdrunner/widget.go | 8 ++++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/cfg/common_settings.go b/cfg/common_settings.go index 8d7a8c39..004e7b81 100644 --- a/cfg/common_settings.go +++ b/cfg/common_settings.go @@ -84,7 +84,7 @@ func NewCommonSettingsFromYAML(name, configKey string, ymlConfig *config.Config) Enabled: ymlConfig.UBool(modulePath+".enabled", false), FocusChar: ymlConfig.UInt(modulePath+".focusChar", -1), RefreshInterval: ymlConfig.UInt(modulePath+".refreshInterval", 300), - Title: ymlConfig.UString(modulePath+".title", name), + Title: ymlConfig.UString(modulePath+".title", ""), } return &common diff --git a/modules/cmdrunner/widget.go b/modules/cmdrunner/widget.go index bb326677..11a0672d 100644 --- a/modules/cmdrunner/widget.go +++ b/modules/cmdrunner/widget.go @@ -35,8 +35,12 @@ func NewWidget(app *tview.Application, settings *Settings) *Widget { func (widget *Widget) Refresh() { widget.execute() - title := tview.TranslateANSI(wtf.Config.UString("wtf.mods.cmdrunner.title", widget.String())) - widget.View.SetTitle(title) + title := widget.settings.common.Title + if title == "" { + title = widget.String() + } + + widget.View.SetTitle(tview.TranslateANSI(title)) widget.View.SetText(widget.result) } From bc967be9e2fb775f2d381481d2332747b1abed8b Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Fri, 19 Apr 2019 10:50:27 -0700 Subject: [PATCH 57/60] WTF-400 Remove last of wtf.Config from Bittex widget --- modules/cryptoexchanges/bittrex/settings.go | 25 +++++++++++++++++---- modules/cryptoexchanges/bittrex/widget.go | 15 +++++-------- wtf/utils.go | 12 ++++++++++ 3 files changed, 39 insertions(+), 13 deletions(-) diff --git a/modules/cryptoexchanges/bittrex/settings.go b/modules/cryptoexchanges/bittrex/settings.go index d35f7f53..3ba3f791 100644 --- a/modules/cryptoexchanges/bittrex/settings.go +++ b/modules/cryptoexchanges/bittrex/settings.go @@ -19,11 +19,19 @@ type colors struct { } } +type currency struct { + displayName string + market []interface{} +} + +type summary struct { + currencies map[string]*currency +} + type Settings struct { colors common *cfg.Common - - summary map[string]interface{} + summary } func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { @@ -40,8 +48,17 @@ func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings.colors.market.field = localConfig.UString("colors.market.field") settings.colors.market.value = localConfig.UString("colors.market.value") - summaryMap, _ := ymlConfig.Map("summary") - settings.summary = summaryMap + settings.summary.currencies = make(map[string]*currency) + for key, val := range localConfig.UMap("summary") { + coercedVal := val.(map[string]interface{}) + + currency := ¤cy{ + displayName: coercedVal["displayName"].(string), + market: coercedVal["market"].([]interface{}), + } + + settings.currencies[key] = currency + } return &settings } diff --git a/modules/cryptoexchanges/bittrex/widget.go b/modules/cryptoexchanges/bittrex/widget.go index 9085626d..49949389 100644 --- a/modules/cryptoexchanges/bittrex/widget.go +++ b/modules/cryptoexchanges/bittrex/widget.go @@ -42,20 +42,17 @@ func NewWidget(app *tview.Application, settings *Settings) *Widget { } func (widget *Widget) setSummaryList() { - sCurrencies := widget.settings.summary - for baseCurrencyName := range sCurrencies { - displayName, _ := wtf.Config.String("wtf.mods.bittrex.summary." + baseCurrencyName + ".displayName") - mCurrencyList := makeSummaryMarketList(baseCurrencyName) - widget.summaryList.addSummaryItem(baseCurrencyName, displayName, mCurrencyList) + for symbol, currency := range widget.settings.summary.currencies { + mCurrencyList := widget.makeSummaryMarketList(symbol, currency.market) + widget.summaryList.addSummaryItem(symbol, currency.displayName, mCurrencyList) } } -func makeSummaryMarketList(currencyName string) []*mCurrency { +func (widget *Widget) makeSummaryMarketList(currencySymbol string, market []interface{}) []*mCurrency { mCurrencyList := []*mCurrency{} - configMarketList, _ := wtf.Config.List("wtf.mods.bittrex.summary." + currencyName + ".market") - for _, mCurrencyName := range configMarketList { - mCurrencyList = append(mCurrencyList, makeMarketCurrency(mCurrencyName.(string))) + for _, marketSymbol := range market { + mCurrencyList = append(mCurrencyList, makeMarketCurrency(marketSymbol.(string))) } return mCurrencyList diff --git a/wtf/utils.go b/wtf/utils.go index 2c1c1f88..49726e8b 100644 --- a/wtf/utils.go +++ b/wtf/utils.go @@ -165,6 +165,18 @@ func SigilStr(len, pos int, view *tview.TextView) string { return sigils } +/* -------------------- Map Conversion -------------------- */ + +func MapToStrs(aMap map[string]interface{}) map[string]string { + results := make(map[string]string) + + for key, val := range aMap { + results[key] = val.(string) + } + + return results +} + /* -------------------- Slice Conversion -------------------- */ func ToInts(slice []interface{}) []int { From 6227b2bcdbe537da8b60734efd92e6e8535a1ea8 Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Fri, 19 Apr 2019 11:37:55 -0700 Subject: [PATCH 58/60] WTF-400 Remove last of wtf.Config from CryptoLive --- modules/cryptoexchanges/bittrex/settings.go | 2 +- .../cryptolive/price/settings.go | 30 ++++++++---- .../cryptolive/price/widget.go | 16 ++---- .../cryptolive/toplist/settings.go | 49 +++++++++++++++---- .../cryptolive/toplist/widget.go | 17 +++---- 5 files changed, 73 insertions(+), 41 deletions(-) diff --git a/modules/cryptoexchanges/bittrex/settings.go b/modules/cryptoexchanges/bittrex/settings.go index 3ba3f791..78f7aeb8 100644 --- a/modules/cryptoexchanges/bittrex/settings.go +++ b/modules/cryptoexchanges/bittrex/settings.go @@ -57,7 +57,7 @@ func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { market: coercedVal["market"].([]interface{}), } - settings.currencies[key] = currency + settings.summary.currencies[key] = currency } return &settings diff --git a/modules/cryptoexchanges/cryptolive/price/settings.go b/modules/cryptoexchanges/cryptolive/price/settings.go index 1e1c66bf..3f39dca6 100644 --- a/modules/cryptoexchanges/cryptolive/price/settings.go +++ b/modules/cryptoexchanges/cryptolive/price/settings.go @@ -5,7 +5,7 @@ import ( "github.com/wtfutil/wtf/cfg" ) -const configKey = "price" +const configKey = "cryptolive" type colors struct { from struct { @@ -29,23 +29,22 @@ type colors struct { } } +type currency struct { + displayName string + to []interface{} +} + type Settings struct { colors common *cfg.Common - currencies map[string]interface{} - top map[string]interface{} + currencies map[string]*currency } func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) - currencies, _ := localConfig.Map("currencies") - top, _ := localConfig.Map("top") - settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), - currencies: currencies, - top: top, + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } settings.colors.from.name = localConfig.UString("colors.from.name") @@ -61,5 +60,18 @@ func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings.colors.top.to.field = localConfig.UString("colors.top.to.field") settings.colors.top.to.value = localConfig.UString("colors.top.to.value") + settings.currencies = make(map[string]*currency) + + for key, val := range localConfig.UMap("currencies") { + coercedVal := val.(map[string]interface{}) + + currency := ¤cy{ + displayName: coercedVal["displayName"].(string), + to: coercedVal["to"].([]interface{}), + } + + settings.currencies[key] = currency + } + return &settings } diff --git a/modules/cryptoexchanges/cryptolive/price/widget.go b/modules/cryptoexchanges/cryptolive/price/widget.go index 42fc5ae9..faada9c1 100644 --- a/modules/cryptoexchanges/cryptolive/price/widget.go +++ b/modules/cryptoexchanges/cryptolive/price/widget.go @@ -6,8 +6,6 @@ import ( "net/http" "sync" "time" - - "github.com/wtfutil/wtf/wtf" ) var baseURL = "https://min-api.cryptocompare.com/data/price" @@ -37,12 +35,10 @@ func NewWidget(settings *Settings) *Widget { func (widget *Widget) setList() { widget.list = &list{} - for currency := range widget.settings.currencies { - displayName, _ := wtf.Config.String("wtf.mods.cryptolive.currencies." + currency + ".displayName") - toList := getToList(currency) - widget.list.addItem(currency, displayName, toList) + for symbol, currency := range widget.settings.currencies { + toList := widget.getToList(symbol) + widget.list.addItem(symbol, currency.displayName, toList) } - } /* -------------------- Exported Functions -------------------- */ @@ -91,12 +87,10 @@ func (widget *Widget) display() { widget.Result = fmt.Sprintf("\n%s", str) } -func getToList(fromName string) []*toCurrency { - toNames, _ := wtf.Config.List("wtf.mods.cryptolive.currencies." + fromName + ".to") - +func (widget *Widget) getToList(symbol string) []*toCurrency { var toList []*toCurrency - for _, to := range toNames { + for _, to := range widget.settings.currencies[symbol].to { toList = append(toList, &toCurrency{ name: to.(string), price: 0, diff --git a/modules/cryptoexchanges/cryptolive/toplist/settings.go b/modules/cryptoexchanges/cryptolive/toplist/settings.go index 97d23eea..8c250c44 100644 --- a/modules/cryptoexchanges/cryptolive/toplist/settings.go +++ b/modules/cryptoexchanges/cryptolive/toplist/settings.go @@ -5,7 +5,7 @@ import ( "github.com/wtfutil/wtf/cfg" ) -const configKey = "toplist" +const configKey = "cryptolive" type colors struct { from struct { @@ -29,23 +29,24 @@ type colors struct { } } +type currency struct { + displayName string + limit int + to []interface{} +} + type Settings struct { colors common *cfg.Common - currencies map[string]interface{} - top map[string]interface{} + currencies map[string]*currency + top map[string]*currency } func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { localConfig, _ := ymlConfig.Get("wtf.mods." + configKey) - currencies, _ := localConfig.Map("currencies") - top, _ := localConfig.Map("top") - settings := Settings{ - common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), - currencies: currencies, - top: top, + common: cfg.NewCommonSettingsFromYAML(name, configKey, ymlConfig), } settings.colors.from.name = localConfig.UString("colors.from.name") @@ -61,5 +62,35 @@ func NewSettingsFromYAML(name string, ymlConfig *config.Config) *Settings { settings.colors.top.to.field = localConfig.UString("colors.top.to.field") settings.colors.top.to.value = localConfig.UString("colors.top.to.value") + settings.currencies = make(map[string]*currency) + + for key, val := range localConfig.UMap("currencies") { + coercedVal := val.(map[string]interface{}) + + limit, _ := coercedVal["limit"].(int) + + currency := ¤cy{ + displayName: coercedVal["displayName"].(string), + limit: limit, + to: coercedVal["to"].([]interface{}), + } + + settings.currencies[key] = currency + } + + for key, val := range localConfig.UMap("top") { + coercedVal := val.(map[string]interface{}) + + limit, _ := coercedVal["limit"].(int) + + currency := ¤cy{ + displayName: coercedVal["displayName"].(string), + limit: limit, + to: coercedVal["to"].([]interface{}), + } + + settings.currencies[key] = currency + } + return &settings } diff --git a/modules/cryptoexchanges/cryptolive/toplist/widget.go b/modules/cryptoexchanges/cryptolive/toplist/widget.go index b06a3b24..58eafd3f 100644 --- a/modules/cryptoexchanges/cryptolive/toplist/widget.go +++ b/modules/cryptoexchanges/cryptolive/toplist/widget.go @@ -7,8 +7,6 @@ import ( "os" "sync" "time" - - "github.com/wtfutil/wtf/wtf" ) var baseURL = "https://min-api.cryptocompare.com/data/top/exchanges" @@ -36,19 +34,16 @@ func NewWidget(settings *Settings) *Widget { } func (widget *Widget) setList() { - for fromCurrency := range widget.settings.top { - displayName := wtf.Config.UString("wtf.mods.cryptolive.top."+fromCurrency+".displayName", "") - limit := wtf.Config.UInt("wtf.mods.cryptolive.top."+fromCurrency+".limit", 1) - widget.list.addItem(fromCurrency, displayName, limit, makeToList(fromCurrency, limit)) + for symbol, currency := range widget.settings.top { + toList := widget.makeToList(symbol, currency.limit) + widget.list.addItem(symbol, currency.displayName, currency.limit, toList) } } -func makeToList(fCurrencyName string, limit int) (list []*tCurrency) { - toList, _ := wtf.Config.List("wtf.mods.cryptolive.top." + fCurrencyName + ".to") - - for _, toCurrency := range toList { +func (widget *Widget) makeToList(symbol string, limit int) (list []*tCurrency) { + for _, to := range widget.settings.top[symbol].to { list = append(list, &tCurrency{ - name: toCurrency.(string), + name: to.(string), info: make([]tInfo, limit), }) } From 6fd9430ef896a0e82b9222214690de7991b4268e Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Fri, 19 Apr 2019 14:06:55 -0700 Subject: [PATCH 59/60] WTF-400 TextWidget properly renders title again --- cfg/common_settings.go | 2 +- wtf/text_widget.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cfg/common_settings.go b/cfg/common_settings.go index 004e7b81..8d7a8c39 100644 --- a/cfg/common_settings.go +++ b/cfg/common_settings.go @@ -84,7 +84,7 @@ func NewCommonSettingsFromYAML(name, configKey string, ymlConfig *config.Config) Enabled: ymlConfig.UBool(modulePath+".enabled", false), FocusChar: ymlConfig.UInt(modulePath+".focusChar", -1), RefreshInterval: ymlConfig.UInt(modulePath+".refreshInterval", 300), - Title: ymlConfig.UString(modulePath+".title", ""), + Title: ymlConfig.UString(modulePath+".title", name), } return &common diff --git a/wtf/text_widget.go b/wtf/text_widget.go index 17ca9277..845c4645 100644 --- a/wtf/text_widget.go +++ b/wtf/text_widget.go @@ -135,7 +135,7 @@ func (widget *TextWidget) addView(app *tview.Application, configKey string) { view.SetBorder(true) view.SetDynamicColors(true) - view.SetTitle(widget.ContextualTitle(widget.name)) + view.SetTitle(widget.ContextualTitle(widget.CommonSettings.Title)) view.SetWrap(false) view.SetChangedFunc(func() { From 79733145f4b62c5ac67f259db6fb9af8065025db Mon Sep 17 00:00:00 2001 From: Chris Cummer Date: Fri, 19 Apr 2019 19:10:22 -0700 Subject: [PATCH 60/60] Gcal widget properly renders title again --- modules/cmdrunner/widget.go | 8 ++------ modules/gcal/display.go | 2 +- 2 files changed, 3 insertions(+), 7 deletions(-) diff --git a/modules/cmdrunner/widget.go b/modules/cmdrunner/widget.go index 11a0672d..edb6fa13 100644 --- a/modules/cmdrunner/widget.go +++ b/modules/cmdrunner/widget.go @@ -35,12 +35,8 @@ func NewWidget(app *tview.Application, settings *Settings) *Widget { func (widget *Widget) Refresh() { widget.execute() - title := widget.settings.common.Title - if title == "" { - title = widget.String() - } - - widget.View.SetTitle(tview.TranslateANSI(title)) + widget.CommonSettings.Title = widget.String() + widget.View.SetTitle(tview.TranslateANSI(widget.CommonSettings.Title)) widget.View.SetText(widget.result) } diff --git a/modules/gcal/display.go b/modules/gcal/display.go index 09fcbafb..749fa81b 100644 --- a/modules/gcal/display.go +++ b/modules/gcal/display.go @@ -32,7 +32,7 @@ func (widget *Widget) display() { widget.mutex.Lock() defer widget.mutex.Unlock() - widget.View.SetTitle(widget.ContextualTitle(widget.Name())) + widget.View.SetTitle(widget.ContextualTitle(widget.settings.common.Title)) widget.View.SetText(widget.contentFrom(widget.calEvents)) }