Add actions to show and hide secrets

Signed-off-by: Sanjula Ganepola <sanjulagane@gmail.com>

.vscode/settings.json

@@ -10,6 +10,7 @@
 	},
 	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
 	"typescript.tsc.autoDetect": "off",
+	"editor.formatOnSave": true,
 	"editor.codeActionsOnSave": {
 		"source.organizeImports": "always"
 	}

package.json

@@ -236,6 +236,18 @@
         "title": "Refresh",
         "icon": "$(refresh)"
       },
+      {
+        "category": "GitHub Local Actions",
+        "command": "githubLocalActions.show",
+        "title": "Show",
+        "icon": "$(eye)"
+      },
+      {
+        "category": "GitHub Local Actions",
+        "command": "githubLocalActions.hide",
+        "title": "Hide",
+        "icon": "$(eye-closed)"
+      },
       {
         "category": "GitHub Local Actions",
         "command": "githubLocalActions.editSetting",
@@ -330,6 +342,14 @@
           "command": "githubLocalActions.refreshSettings",
           "when": "never"
         },
+        {
+          "command": "githubLocalActions.show",
+          "when": "never"
+        },
+        {
+          "command": "githubLocalActions.hide",
+          "when": "never"
+        },
         {
           "command": "githubLocalActions.editSetting",
           "when": "never"
@@ -461,10 +481,20 @@
           "when": "view == history && viewItem =~ /^githubLocalActions.history.*/",
           "group": "inline@3"
         },
+        {
+          "command": "githubLocalActions.show",
+          "when": "view == settings && viewItem =~ /^githubLocalActions.secret(?!s)_hide.*/",
+          "group": "inline@0"
+        },
+        {
+          "command": "githubLocalActions.hide",
+          "when": "view == settings && viewItem =~ /^githubLocalActions.secret(?!s)_show.*/",
+          "group": "inline@0"
+        },
         {
           "command": "githubLocalActions.editSetting",
           "when": "view == settings && viewItem =~ /^githubLocalActions.(secret|variable|input|runner)(?!s).*/",
-          "group": "inline@0"
+          "group": "inline@1"
         }
       ]
     },

src/settingsManager.ts

@@ -7,7 +7,13 @@ export interface Setting {
     key: string,
     value: string,
     password: boolean,
-    selected: boolean
+    selected: boolean,
+    visible: Visibility
+}
+
+export enum Visibility {
+    show = 'show',
+    hide = 'hide'
 }
 
 export class SettingsManager {
@@ -24,20 +30,20 @@ export class SettingsManager {
     }
 
     async getSettings(workspaceFolder: WorkspaceFolder, isUserSelected: boolean) {
-        const secrets = (await this.getSetting(workspaceFolder, SettingsManager.secretsRegExp, StorageKey.Secrets, true)).filter(secret => !isUserSelected || secret.selected);
+        const secrets = (await this.getSetting(workspaceFolder, SettingsManager.secretsRegExp, StorageKey.Secrets, true, Visibility.hide)).filter(secret => !isUserSelected || secret.selected);
-        const variables = (await this.getSetting(workspaceFolder, SettingsManager.variablesRegExp, StorageKey.Variables, false)).filter(variable => !isUserSelected || variable.selected);
+        const variables = (await this.getSetting(workspaceFolder, SettingsManager.variablesRegExp, StorageKey.Variables, false, Visibility.show)).filter(variable => !isUserSelected || variable.selected);
-        const inputs = (await this.getSetting(workspaceFolder, SettingsManager.inputsRegExp, StorageKey.Inputs, false)).filter(input => !isUserSelected || (input.selected && input.value));
+        const inputs = (await this.getSetting(workspaceFolder, SettingsManager.inputsRegExp, StorageKey.Inputs, false, Visibility.show)).filter(input => !isUserSelected || (input.selected && input.value));
-        const runners = (await this.getSetting(workspaceFolder, SettingsManager.runnersRegExp, StorageKey.Runners, false)).filter(runner => !isUserSelected || (runner.selected && runner.value));
+        const runners = (await this.getSetting(workspaceFolder, SettingsManager.runnersRegExp, StorageKey.Runners, false, Visibility.show)).filter(runner => !isUserSelected || (runner.selected && runner.value));
 
         return {
             secrets: secrets,
             variables: variables,
             inputs: inputs,
             runners: runners
-        }
+        };
     }
 
-    async getSetting(workspaceFolder: WorkspaceFolder, regExp: RegExp, storageKey: StorageKey, password: boolean): Promise<Setting[]> {
+    async getSetting(workspaceFolder: WorkspaceFolder, regExp: RegExp, storageKey: StorageKey, password: boolean, visible: Visibility): Promise<Setting[]> {
         const settings: Setting[] = [];
 
         const workflows = await act.workflowsManager.getWorkflows(workspaceFolder);
@@ -46,7 +52,7 @@ export class SettingsManager {
                 continue;
             }
 
-            const workflowSettings = this.findInWorkflow(workflow.fileContent, regExp, password);
+            const workflowSettings = this.findInWorkflow(workflow.fileContent, regExp, password, visible);
             for (const workflowSetting of workflowSettings) {
                 const existingSetting = settings.find(setting => setting.key === workflowSetting.key);
                 if (!existingSetting) {
@@ -71,7 +77,8 @@ export class SettingsManager {
                         key: setting.key,
                         value: value,
                         password: existingSetting.password,
-                        selected: existingSetting.selected
+                        selected: existingSetting.selected,
+                        visible: existingSetting.visible
                     };
                 }
             }
@@ -102,16 +109,20 @@ export class SettingsManager {
 
         await this.storageManager.update(storageKey, existingSettings);
         if (storageKey === StorageKey.Secrets) {
+            if (value === '') {
+                await this.secretManager.delete(workspaceFolder, storageKey, newSetting.key);
+            } else {
                 await this.secretManager.store(workspaceFolder, storageKey, newSetting.key, value);
             }
         }
+    }
 
-    private findInWorkflow(content: string, regExp: RegExp, password: boolean) {
+    private findInWorkflow(content: string, regExp: RegExp, password: boolean, visible: Visibility) {
         const results: Setting[] = [];
 
         const matches = content.matchAll(regExp);
         for (const match of matches) {
-            results.push({ key: match[1], value: '', password: password, selected: false });
+            results.push({ key: match[1], value: '', password: password, selected: false, visible: visible });
         }
 
         return results;

src/views/settings/setting.ts

@@ -1,5 +1,5 @@
 import { ThemeIcon, TreeItem, TreeItemCheckboxState, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
-import { Setting } from "../../settingsManager";
+import { Setting, Visibility } from "../../settingsManager";
 import { StorageKey } from "../../storageManager";
 import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
 
@@ -7,30 +7,63 @@ export default class SettingTreeItem extends TreeItem implements GithubLocalActi
     setting: Setting;
     storageKey: StorageKey;
 
-    constructor(public workspaceFolder: WorkspaceFolder, setting: Setting, storageKey: StorageKey, treeItem: { description: string, contextValue: string, iconPath: ThemeIcon }) {
+    constructor(public workspaceFolder: WorkspaceFolder, setting: Setting, storageKey: StorageKey, treeItem: { contextValue: string, iconPath: ThemeIcon }) {
         super(setting.key, TreeItemCollapsibleState.None);
         this.setting = setting;
         this.storageKey = storageKey;
-        this.description = treeItem.description;
+        if (setting.password) {
-        this.contextValue = treeItem.contextValue;
+            this.description = (setting.visible === Visibility.hide && setting.value) ? '••••••••' : setting.value;
+        } else {
+            this.description = setting.value;
+        }
+        this.contextValue = `${treeItem.contextValue}_${setting.password ? setting.visible : ''}`;
         this.iconPath = treeItem.iconPath;
         this.checkboxState = setting.selected ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked;
     }
 
     static getSecretTreeItem(workspaceFolder: WorkspaceFolder, secret: Setting): SettingTreeItem {
-        return new SettingTreeItem(workspaceFolder, secret, StorageKey.Secrets, { description: secret.value ? '••••••••' : '', contextValue: 'githubLocalActions.secret', iconPath: new ThemeIcon('key') });
+        return new SettingTreeItem(
+            workspaceFolder,
+            secret,
+            StorageKey.Secrets,
+            {
+                contextValue: 'githubLocalActions.secret',
+                iconPath: new ThemeIcon('key')
+            }
+        );
     }
 
     static getVariableTreeItem(workspaceFolder: WorkspaceFolder, variable: Setting): SettingTreeItem {
-        return new SettingTreeItem(workspaceFolder, variable, StorageKey.Variables, { description: variable.value, contextValue: 'githubLocalActions.variable', iconPath: new ThemeIcon('symbol-variable') });
+        return new SettingTreeItem(
+            workspaceFolder,
+            variable, StorageKey.Variables,
+            {
+                contextValue: 'githubLocalActions.variable',
+                iconPath: new ThemeIcon('symbol-variable')
+            }
+        );
     }
 
     static getInputTreeItem(workspaceFolder: WorkspaceFolder, input: Setting): SettingTreeItem {
-        return new SettingTreeItem(workspaceFolder, input, StorageKey.Inputs, { description: input.value, contextValue: 'githubLocalActions.input', iconPath: new ThemeIcon('symbol-parameter') });
+        return new SettingTreeItem(
+            workspaceFolder,
+            input, StorageKey.Inputs,
+            {
+                contextValue: 'githubLocalActions.input',
+                iconPath: new ThemeIcon('symbol-parameter')
+            }
+        );
     }
 
     static getRunnerTreeItem(workspaceFolder: WorkspaceFolder, runner: Setting): SettingTreeItem {
-        return new SettingTreeItem(workspaceFolder, runner, StorageKey.Runners, { description: runner.value, contextValue: 'githubLocalActions.runner', iconPath: new ThemeIcon('vm-connect') });
+        return new SettingTreeItem(
+            workspaceFolder,
+            runner, StorageKey.Runners,
+            {
+                contextValue: 'githubLocalActions.runner',
+                iconPath: new ThemeIcon('vm-connect')
+            }
+        );
     }
 
     async getChildren(): Promise<GithubLocalActionsTreeItem[]> {

src/views/settings/settingsTreeDataProvider.ts

@@ -1,5 +1,6 @@
 import { CancellationToken, commands, EventEmitter, ExtensionContext, TreeCheckboxChangeEvent, TreeDataProvider, TreeItem, TreeItemCheckboxState, window, workspace } from "vscode";
 import { act } from "../../extension";
+import { Visibility } from "../../settingsManager";
 import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
 import SettingTreeItem from "./setting";
 import WorkspaceFolderSettingsTreeItem from "./workspaceFolderSettings";
@@ -14,16 +15,30 @@ export default class SettingsTreeDataProvider implements TreeDataProvider<Github
             commands.registerCommand('githubLocalActions.refreshSettings', async () => {
                 this.refresh();
             }),
+            commands.registerCommand('githubLocalActions.show', async (settingTreeItem: SettingTreeItem) => {
+                const newSetting = settingTreeItem.setting;
+                newSetting.visible = Visibility.show;
+                await act.settingsManager.editSetting(settingTreeItem.workspaceFolder, newSetting, settingTreeItem.storageKey);
+                this.refresh();
+            }),
+            commands.registerCommand('githubLocalActions.hide', async (settingTreeItem: SettingTreeItem) => {
+                const newSetting = settingTreeItem.setting;
+                newSetting.visible = Visibility.hide;
+                await act.settingsManager.editSetting(settingTreeItem.workspaceFolder, newSetting, settingTreeItem.storageKey);
+                this.refresh();
+            }),
             commands.registerCommand('githubLocalActions.editSetting', async (settingTreeItem: SettingTreeItem) => {
                 const newValue = await window.showInputBox({
                     prompt: `Enter the value for ${settingTreeItem.setting.value}`,
                     placeHolder: `Setting value`,
-                    value: settingTreeItem.setting.value,
+                    value: settingTreeItem.setting.visible === Visibility.hide && settingTreeItem.setting.password ? '' : settingTreeItem.setting.value,
-                    password: settingTreeItem.setting.password
+                    password: settingTreeItem.setting.visible === Visibility.hide && settingTreeItem.setting.password
                 });
 
                 if (newValue !== undefined) {
-                    await act.settingsManager.editSetting(settingTreeItem.workspaceFolder, { key: settingTreeItem.setting.key, value: newValue, selected: settingTreeItem.setting.selected, password: settingTreeItem.setting.password }, settingTreeItem.storageKey);
+                    const newSetting = settingTreeItem.setting;
+                    newSetting.value = newValue;
+                    await act.settingsManager.editSetting(settingTreeItem.workspaceFolder, newSetting, settingTreeItem.storageKey);
                     this.refresh();
                 }
             })
@@ -48,7 +63,9 @@ export default class SettingsTreeDataProvider implements TreeDataProvider<Github
 
     async onDidChangeCheckboxState(event: TreeCheckboxChangeEvent<SettingTreeItem>) {
         for await (const [treeItem, state] of event.items) {
-            await act.settingsManager.editSetting(treeItem.workspaceFolder, { key: treeItem.setting.key, value: treeItem.setting.value, selected: state === TreeItemCheckboxState.Checked, password: treeItem.setting.password }, treeItem.storageKey);
+            const newSetting = treeItem.setting;
+            newSetting.selected = (state === TreeItemCheckboxState.Checked);
+            await act.settingsManager.editSetting(treeItem.workspaceFolder, newSetting, treeItem.storageKey);
         }
         this.refresh();
     }