DevInfra/github-local-actions
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add secrets, variables, and inputs to storage

Browse Source 
Signed-off-by: Sanjula Ganepola <sanjulagane@gmail.com>
This commit is contained in:
Sanjula Ganepola
2024-10-20 18:55:28 -04:00
parent 524a724279
commit 551f6baa2f
18 changed files with 226 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
package.json
View File

@@ -259,12 +259,6 @@
"command": "githubLocalActions.addRunner",
"title": "Add Runner",
"icon": "$(add)"
},
{
"category": "GitHub Local Actions",
"command": "githubLocalActions.editContainerEngine",
"title": "Edit Container Engine",
"icon": "$(edit)"
}
],
"menus": {
@@ -352,10 +346,6 @@
{
"command": "githubLocalActions.addRunner",
"when": "never"
},
{
"command": "githubLocalActions.editContainerEngine",
"when": "never"
}
],
"view/title": [
@@ -480,11 +470,6 @@
"command": "githubLocalActions.addRunner",
"when": "view == settings && viewItem =~ /^githubLocalActions.runners.*/",
"group": "inline@0"
},
{
"command": "githubLocalActions.editContainerEngine",
"when": "view == settings && viewItem =~ /^githubLocalActions.containerEngine(?!s).*/",
"group": "inline@0"
}
]
},

65
src/act.ts
View File

@@ -45,10 +45,67 @@ export enum Event {
}
export enum Option {
Workflows = '--workflows',
ActionCachePath = '--action-cache-path',
ActionOfflineMode = '--action-offline-mode',
Actor = '--actor',
ArtifactServerAddr = '--artifact-server-addr',
ArtifactServerPath = '--artifact-server-path',
ArtifactServerPort = '--artifact-server-port',
Bind = '--bind',
BugReport = '--bug-report',
CacheServerAddr = '--cache-server-addr',
CacheServerPath = '--cache-server-path',
CacheServerPort = '--cache-server-port',
ContainerArchitecture = '--container-architecture',
ContainerCapAdd = '--container-cap-add',
ContainerCapDrop = '--container-cap-drop',
ContainerDaemonSocket = '--container-daemon-socket',
ContainerOptions = '--container-options',
DefaultBranch = '--defaultbranch',
DetectEvent = '--detect-event',
Directory = '--directory',
DryRun = '--dryrun',
Env = '--env',
EnvFile = '--env-file',
EventPath = '--eventpath',
GitHubInstance = '--github-instance',
Graph = '--graph',
Help = '--help',
Input = '--input',
InputFile = '--input-file',
InsecureSecrets = '--insecure-secrets',
Job = '--job',
Variable = '--var',
Json = "--json"
Json = '--json',
List = '--list',
LocalRepository = '--local-repository',
LogPrefixJobId = '--log-prefix-job-id',
ManPage = '--man-page',
Matrix = '--matrix',
Network = '--network',
NoCacheServer = '--no-cache-server',
NoRecurse = '--no-recurse',
NoSkipCheckout = '--no-skip-checkout',
Platform = '--platform',
Privileged = '--privileged',
Pull = '--pull',
Quiet = '--quiet',
Rebuild = '--rebuild',
RemoteName = '--remote-name',
ReplaceGHEActionTokenWithGitHubCom = '--replace-ghe-action-token-with-github-com',
ReplaceGHEActionWithGitHubCom = '--replace-ghe-action-with-github-com',
Reuse = '--reuse',
Rm = '--rm',
Secret = '--secret',
SecretFile = '--secret-file',
UseGitignore = '--use-gitignore',
UseNewActionCache = '--use-new-action-cache',
Userns = '--userns',
Var = '--var',
VarFile = '--var-file',
Verbose = '--verbose',
Version = '--version',
Watch = '--watch',
Workflows = '--workflows'
}
export interface CommandArgs {
@@ -73,7 +130,7 @@ export class Act {
this.componentsManager = new ComponentsManager();
this.workflowsManager = new WorkflowsManager();
this.historyManager = new HistoryManager(this.storageManager);
this.settingsManager = new SettingsManager();
this.settingsManager = new SettingsManager(this.storageManager);
switch (process.platform) {
case 'win32':

164
src/settingsManager.ts
View File

@@ -1,14 +1,6 @@
import { WorkspaceFolder } from "vscode";
import { Workflow } from "./workflowsManager";
export interface Settings {
environments: Environment[],
secrets: Secret[],
variables: Variable[],
inputs: Input[],
runners: Runner[],
containerEngines: ContainerEngine[]
}
import { act } from "./extension";
import { StorageKey, StorageManager } from "./storageManager";
export interface Environment {
name: string
@@ -38,53 +30,33 @@ export interface Runner {
selected: boolean
}
export interface ContainerEngine {
key: string,
value: string,
selected: boolean
}
export class SettingsManager {
settings: { [path: string]: Settings }
storageManager: StorageManager;
constructor() {
this.settings = {};
constructor(storageManager: StorageManager) {
this.storageManager = storageManager;
}
getSettings(workspaceFolder: WorkspaceFolder) {
if (!this.settings[workspaceFolder.uri.fsPath]) {
this.settings[workspaceFolder.uri.fsPath] = {
environments: [],
secrets: [],
variables: [],
inputs: [],
runners: [],
containerEngines: [
{
key: 'DOCKER_HOST',
value: '',
selected: false
}
]
}
}
return this.settings[workspaceFolder.uri.fsPath];
}
getEnvironments(workflow: Workflow): Environment[] {
async getEnvironments(workspaceFolder: WorkspaceFolder): Promise<Environment[]> {
const environments: Environment[] = [];
if (!workflow.yaml) {
return environments;
}
const jobs = workflow.yaml?.jobs;
if (jobs) {
for (const details of Object.values<any>(jobs)) {
if (details.environment) {
environments.push({
name: details.environment
});
const workflows = await act.workflowsManager.getWorkflows(workspaceFolder);
for (const workflow of workflows) {
if (!workflow.yaml) {
continue;
}
const jobs = workflow.yaml?.jobs;
if (jobs) {
for (const details of Object.values<any>(jobs)) {
if (details.environment) {
const existingEnvironment = environments.find(environment => environment.name === details.environment);
if (!existingEnvironment) {
environments.push({
name: details.environment
});
}
}
}
}
}
@@ -92,61 +64,71 @@ export class SettingsManager {
return environments;
}
getSecrets(workflow: Workflow): Secret[] {
const secrets: Secret[] = [];
if (!workflow.fileContent) {
return secrets;
async getSetting<T extends Secret | Variable | Input>(workspaceFolder: WorkspaceFolder, regExp: RegExp, storageKey: StorageKey): Promise<T[]> {
const existingSettings = this.storageManager.get<{ [path: string]: T[] }>(storageKey) || {};
const settings: T[] = [];
const workflows = await act.workflowsManager.getWorkflows(workspaceFolder);
for (const workflow of workflows) {
if (!workflow.fileContent) {
continue;
}
settings.push(...this.findInWorkflow<T>(workflow.fileContent, regExp));
}
return this.findInWorkflow(workflow.fileContent, /\${{\s*secrets\.(.*?)\s*}}/g);
if (existingSettings[workspaceFolder.uri.fsPath]) {
for (const [index, setting] of settings.entries()) {
const existingSetting = existingSettings[workspaceFolder.uri.fsPath].find(existingSetting => existingSetting.key === setting.key);
if (existingSetting) {
settings[index] = {
key: setting.key,
value: existingSetting.value,
selected: existingSetting.selected
} as T;
}
}
}
existingSettings[workspaceFolder.uri.fsPath] = settings;
this.storageManager.update(storageKey, existingSettings);
return settings;
}
getVariables(workflow: Workflow): Variable[] {
const variables: Variable[] = [];
if (!workflow.fileContent) {
return variables;
editSetting<T extends Secret | Variable | Input>(workspaceFolder: WorkspaceFolder, newSetting: T, storageKey: StorageKey) {
const existingSettings = this.storageManager.get<{ [path: string]: T[] }>(storageKey) || {};
if (existingSettings[workspaceFolder.uri.fsPath]) {
const index = existingSettings[workspaceFolder.uri.fsPath].findIndex(setting => setting.key === newSetting.key);
if (index > -1) {
existingSettings[workspaceFolder.uri.fsPath][index] = newSetting;
} else {
existingSettings[workspaceFolder.uri.fsPath].push(newSetting);
}
} else {
existingSettings[workspaceFolder.uri.fsPath] = [newSetting];
}
return this.findInWorkflow(workflow.fileContent, /\${{\s*vars\.(.*?)(?:\s*==\s*(.*?))?\s*}}/g);
this.storageManager.update(storageKey, existingSettings);
}
getInputs(workflow: Workflow): Input[] {
const inputs: Variable[] = [];
if (!workflow.fileContent) {
return inputs;
private findInWorkflow<T extends Secret | Variable | Input>(content: string, regExp: RegExp) {
const results: (T)[] = [];
const matches = content.matchAll(regExp);
for (const match of matches) {
results.push({ key: match[1], value: '', selected: false } as T);
}
return this.findInWorkflow(workflow.fileContent, /\${{\s*(?:inputs|github\.event\.inputs)\.(.*?)(?:\s*==\s*(.*?))?\s*}}/g);
return results;
}
editSecret(workspaceFolder: WorkspaceFolder, secret: Secret, newValue: string) {
}
editVariable(workspaceFolder: WorkspaceFolder, variable: Variable, newValue: string) {
}
editInput(workspaceFolder: WorkspaceFolder, input: Input, newValue: string) {
getRunners(workspaceFolder: WorkspaceFolder): Runner[] {
return [];
}
addRunner(workspaceFolder: WorkspaceFolder, runner: Runner) {
}
editContainerEngine(workspaceFolder: WorkspaceFolder, containerEngine: ContainerEngine, newValue: string) {
}
private findInWorkflow(content: string, regExp: RegExp) {
const results: (Secret | Variable | Input)[] = [];
const matches = content.matchAll(regExp);
for (const match of matches) {
results.push({ key: match[1], value: '', selected: false });
}
return results;
}
}

15
src/storageManager.ts
View File

@@ -1,12 +1,15 @@
import { ExtensionContext } from "vscode";
export enum StorageKey {
WorkspaceHistory = 'workspaceHistory'
WorkspaceHistory = 'workspaceHistory',
Secrets = 'secrets',
Variables = 'variables',
Inputs = 'inputs'
}
export class StorageManager {
private context: ExtensionContext;
private storageKey: string = 'githubLocalActions';
private extensionKey: string = 'githubLocalActions';
constructor(context: ExtensionContext) {
this.context = context;
@@ -16,11 +19,11 @@ export class StorageManager {
return this.context.globalState.keys();
}
get<T>(key: StorageKey): T | undefined {
return this.context.globalState.get<T>(`${this.storageKey}.${key}`);
get<T>(storageKey: StorageKey): T | undefined {
return this.context.globalState.get<T>(`${this.extensionKey}.${storageKey}`);
}
async update(key: StorageKey, value: any): Promise<void> {
await this.context.globalState.update(`${this.storageKey}.${key}`, value);
async update(storageKey: StorageKey, value: any): Promise<void> {
await this.context.globalState.update(`${this.extensionKey}.${storageKey}`, value);
}
}

2
src/views/history/historyTreeDataProvider.ts
View File

@@ -70,7 +70,7 @@ export default class HistoryTreeDataProvider implements TreeDataProvider<GithubL
const workspaceFolders = workspace.workspaceFolders;
if (workspaceFolders) {
if (workspaceFolders.length === 1) {
return await new WorkspaceFolderHistoryTreeItem(workspaceFolders[0]).getChildren();
items.push(...await new WorkspaceFolderHistoryTreeItem(workspaceFolders[0]).getChildren());
} else if (workspaceFolders.length > 1) {
for (const workspaceFolder of workspaceFolders) {
items.push(new WorkspaceFolderHistoryTreeItem(workspaceFolder));

18
src/views/settings/containerEngine.ts
View File

@@ -1,18 +0,0 @@
import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
import { ContainerEngine } from "../../settingsManager";
import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
export default class ContainerEngineTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
static contextValue = 'githubLocalActions.containerEngine';
constructor(public workspaceFolder: WorkspaceFolder, containerEngine: ContainerEngine) {
super(containerEngine.key, TreeItemCollapsibleState.None);
this.description = containerEngine.value;
this.contextValue = ContainerEngineTreeItem.contextValue;
this.iconPath = new ThemeIcon('code');
}
async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
return [];
}
}

25
src/views/settings/containerEngines.ts
View File

@@ -1,25 +0,0 @@
import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
import { act } from "../../extension";
import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
import ContainerEngineTreeItem from "./containerEngine";
export default class ContainerEnginesTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
static contextValue = 'githubLocalActions.containerEngines';
constructor(public workspaceFolder: WorkspaceFolder) {
super('Container Engines', TreeItemCollapsibleState.Collapsed);
this.contextValue = ContainerEnginesTreeItem.contextValue;
this.iconPath = new ThemeIcon('server-process');
}
async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
const items: GithubLocalActionsTreeItem[] = [];
const containerEngines = act.settingsManager.getSettings(this.workspaceFolder).containerEngines;
for (const containerEngine of containerEngines) {
items.push(new ContainerEngineTreeItem(this.workspaceFolder, containerEngine));
}
return items;
}
}

2
src/views/settings/environment.ts
View File

@@ -4,9 +4,11 @@ import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
export default class EnvironmentTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
static contextValue = 'githubLocalActions.environment';
environment: Environment;
constructor(public workspaceFolder: WorkspaceFolder, environment: Environment) {
super(environment.name, TreeItemCollapsibleState.None);
this.environment = environment;
this.contextValue = EnvironmentTreeItem.contextValue;
this.iconPath = new ThemeIcon('server');
}

11
src/views/settings/environments.ts
View File

@@ -13,8 +13,13 @@ export default class EnvironmentsTreeItem extends TreeItem implements GithubLoca
}
async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
const workflows = await act.workflowsManager.getWorkflows(this.workspaceFolder);
const environments = [...new Set(workflows.map(workflow => act.settingsManager.getEnvironments(workflow)).flat())];
return environments.map(environment => new EnvironmentTreeItem(this.workspaceFolder, environment));
const items: GithubLocalActionsTreeItem[] = [];
const environments = await act.settingsManager.getEnvironments(this.workspaceFolder);
for (const environment of environments) {
items.push(new EnvironmentTreeItem(this.workspaceFolder, environment));
}
return items;
}
}

4
src/views/settings/input.ts
View File

@@ -4,13 +4,15 @@ import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
export default class InputTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
static contextValue = 'githubLocalActions.input';
input: Input
constructor(public workspaceFolder: WorkspaceFolder, input: Input) {
super(input.key, TreeItemCollapsibleState.None);
this.input = input;
this.description = input.value;
this.contextValue = InputTreeItem.contextValue;
this.iconPath = new ThemeIcon('symbol-parameter');
this.checkboxState = TreeItemCheckboxState.Unchecked;
this.checkboxState = input.selected ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked;
}
async getChildren(): Promise<GithubLocalActionsTreeItem[]> {

12
src/views/settings/inputs.ts
View File

@@ -1,5 +1,6 @@
import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
import { act } from "../../extension";
import { StorageKey } from "../../storageManager";
import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
import InputTreeItem from "./input";
@@ -13,8 +14,13 @@ export default class InputsTreeItem extends TreeItem implements GithubLocalActio
}
async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
const workflows = await act.workflowsManager.getWorkflows(this.workspaceFolder);
const inputs = [...new Set(workflows.map(workflow => act.settingsManager.getInputs(workflow)).flat())];
return inputs.map(input => new InputTreeItem(this.workspaceFolder, input));
const items: GithubLocalActionsTreeItem[] = [];
const inputs = await act.settingsManager.getSetting(this.workspaceFolder, /\${{\s*(?:inputs|github\.event\.inputs)\.(.*?)(?:\s*==\s*(.*?))?\s*}}/g, StorageKey.Inputs);
for (const input of inputs) {
items.push(new InputTreeItem(this.workspaceFolder, input));
}
return items;
}
}

4
src/views/settings/secret.ts
View File

@@ -4,13 +4,15 @@ import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
export default class SecretTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
static contextValue = 'githubLocalActions.secret';
secret: Secret;
constructor(public workspaceFolder: WorkspaceFolder, secret: Secret) {
super(secret.key, TreeItemCollapsibleState.None);
this.secret = secret;
this.description = secret.value ? '••••••••' : '';
this.contextValue = SecretTreeItem.contextValue;
this.iconPath = new ThemeIcon('key');
this.checkboxState = TreeItemCheckboxState.Unchecked;
this.checkboxState = secret.selected ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked;
}
async getChildren(): Promise<GithubLocalActionsTreeItem[]> {

12
src/views/settings/secrets.ts
View File

@@ -1,5 +1,6 @@
import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
import { act } from "../../extension";
import { StorageKey } from "../../storageManager";
import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
import SecretTreeItem from "./secret";
@@ -13,8 +14,13 @@ export default class SecretsTreeItem extends TreeItem implements GithubLocalActi
}
async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
const workflows = await act.workflowsManager.getWorkflows(this.workspaceFolder);
const secrets = [...new Set(workflows.map(workflow => act.settingsManager.getSecrets(workflow)).flat())];
return secrets.map(secret => new SecretTreeItem(this.workspaceFolder, secret));
const items: GithubLocalActionsTreeItem[] = [];
const secrets = await act.settingsManager.getSetting(this.workspaceFolder, /\${{\s*secrets\.(.*?)\s*}}/g, StorageKey.Secrets);
for (const secret of secrets) {
items.push(new SecretTreeItem(this.workspaceFolder, secret));
}
return items;
}
}

43
src/views/settings/settingsTreeDataProvider.ts
View File

@@ -1,7 +1,7 @@
import { CancellationToken, commands, EventEmitter, ExtensionContext, TreeDataProvider, TreeItem, workspace } from "vscode";
import { CancellationToken, commands, EventEmitter, ExtensionContext, TreeDataProvider, TreeItem, window, workspace } from "vscode";
import { act } from "../../extension";
import { StorageKey } from "../../storageManager";
import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
import ContainerEngineTreeItem from "./containerEngine";
import InputTreeItem from "./input";
import RunnersTreeItem from "./runners";
import SecretTreeItem from "./secret";
@@ -19,19 +19,44 @@ export default class SettingsTreeDataProvider implements TreeDataProvider<Github
this.refresh();
}),
commands.registerCommand('githubLocalActions.editSecret', async (secretTreeItem: SecretTreeItem) => {
//TODO: Implement
const newValue = await window.showInputBox({
prompt: `Enter the value for ${secretTreeItem.secret.value}`,
placeHolder: `Secret value`,
value: secretTreeItem.secret.value,
password: true
});
if (newValue) {
act.settingsManager.editSetting(secretTreeItem.workspaceFolder, { key: secretTreeItem.secret.key, value: newValue, selected: secretTreeItem.secret.selected }, StorageKey.Secrets);
this.refresh();
}
}),
commands.registerCommand('githubLocalActions.editVariable', async (variableTreeItem: VariableTreeItem) => {
//TODO: Implement
const newValue = await window.showInputBox({
prompt: `Enter the value for ${variableTreeItem.variable.value}`,
placeHolder: `Variable value`,
value: variableTreeItem.variable.value
});
if (newValue) {
act.settingsManager.editSetting(variableTreeItem.workspaceFolder, { key: variableTreeItem.variable.key, value: newValue, selected: variableTreeItem.variable.selected }, StorageKey.Variables);
this.refresh();
}
}),
commands.registerCommand('githubLocalActions.editInput', async (inputTreeItem: InputTreeItem) => {
//TODO: Implement
const newValue = await window.showInputBox({
prompt: `Enter the value for ${inputTreeItem.input.value}`,
placeHolder: `Input value`,
value: inputTreeItem.input.value
});
if (newValue) {
act.settingsManager.editSetting(inputTreeItem.workspaceFolder, { key: inputTreeItem.input.key, value: newValue, selected: inputTreeItem.input.selected }, StorageKey.Inputs);
this.refresh();
}
}),
commands.registerCommand('githubLocalActions.addRunner', async (runnersTreeItem: RunnersTreeItem) => {
//TODO: Implement
}),
commands.registerCommand('githubLocalActions.editContainerEngine', async (containerEngineTreeItem: ContainerEngineTreeItem) => {
//TODO: Implement
})
);
}
@@ -62,7 +87,7 @@ export default class SettingsTreeDataProvider implements TreeDataProvider<Github
const workspaceFolders = workspace.workspaceFolders;
if (workspaceFolders) {
if (workspaceFolders.length === 1) {
return await new WorkspaceFolderSettingsTreeItem(workspaceFolders[0]).getChildren();
items.push(...await new WorkspaceFolderSettingsTreeItem(workspaceFolders[0]).getChildren());
} else if (workspaceFolders.length > 1) {
for (const workspaceFolder of workspaceFolders) {
items.push(new WorkspaceFolderSettingsTreeItem(workspaceFolder));

4
src/views/settings/variable.ts
View File

@@ -4,13 +4,15 @@ import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
export default class VariableTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
static contextValue = 'githubLocalActions.variable';
variable: Variable;
constructor(public workspaceFolder: WorkspaceFolder, variable: Variable) {
super(variable.key, TreeItemCollapsibleState.None);
this.variable = variable;
this.description = variable.value;
this.contextValue = VariableTreeItem.contextValue;
this.iconPath = new ThemeIcon('symbol-variable');
this.checkboxState = TreeItemCheckboxState.Unchecked;
this.checkboxState = variable.selected ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked;
}
async getChildren(): Promise<GithubLocalActionsTreeItem[]> {

12
src/views/settings/variables.ts
View File

@@ -2,6 +2,7 @@ import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "
import { act } from "../../extension";
import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
import VariableTreeItem from "./variable";
import { StorageKey } from "../../storageManager";
export default class VariablesTreeItem extends TreeItem implements GithubLocalActionsTreeItem {
static contextValue = 'githubLocalActions.variables';
@@ -13,8 +14,13 @@ export default class VariablesTreeItem extends TreeItem implements GithubLocalAc
}
async getChildren(): Promise<GithubLocalActionsTreeItem[]> {
const workflows = await act.workflowsManager.getWorkflows(this.workspaceFolder);
const variables = [...new Set(workflows.map(workflow => act.settingsManager.getVariables(workflow)).flat())];
return variables.map(variable => new VariableTreeItem(this.workspaceFolder, variable));
const items: GithubLocalActionsTreeItem[] = [];
const variables = await act.settingsManager.getSetting(this.workspaceFolder, /\${{\s*vars\.(.*?)(?:\s*==\s*(.*?))?\s*}}/g, StorageKey.Variables);
for (const variable of variables) {
items.push(new VariableTreeItem(this.workspaceFolder, variable));
}
return items;
}
}

4
src/views/settings/workspaceFolderSettings.ts
View File

@@ -1,6 +1,5 @@
import { ThemeIcon, TreeItem, TreeItemCollapsibleState, WorkspaceFolder } from "vscode";
import { GithubLocalActionsTreeItem } from "../githubLocalActionsTreeItem";
import ContainerEnginesTreeItem from "./containerEngines";
import EnvironmentsTreeItem from "./environments";
import InputsTreeItem from "./inputs";
import RunnersTreeItem from "./runners";
@@ -24,8 +23,7 @@ export default class WorkspaceFolderSettingsTreeItem extends TreeItem implements
new SecretsTreeItem(this.workspaceFolder),
new VariablesTreeItem(this.workspaceFolder),
new InputsTreeItem(this.workspaceFolder),
new RunnersTreeItem(this.workspaceFolder),
new ContainerEnginesTreeItem(this.workspaceFolder)
new RunnersTreeItem(this.workspaceFolder)
]);
return items;

2
src/views/workflows/workflowsTreeDataProvider.ts
View File

@@ -75,7 +75,7 @@ export default class WorkflowsTreeDataProvider implements TreeDataProvider<Githu
const workspaceFolders = workspace.workspaceFolders;
if (workspaceFolders) {
if (workspaceFolders.length === 1) {
return await new WorkspaceFolderWorkflowsTreeItem(workspaceFolders[0]).getChildren();
items.push(...await new WorkspaceFolderWorkflowsTreeItem(workspaceFolders[0]).getChildren());
} else if (workspaceFolders.length > 1) {
for (const workspaceFolder of workspaceFolders) {
items.push(new WorkspaceFolderWorkflowsTreeItem(workspaceFolder));