Add 'Extract Task spec' CodeAction (redhat-developer#546)

* redhat-developer#511 add 'Extract Task spec' CodeAction

Signed-off-by: Yevhen Vydolob <[email protected]>

* Set 'ignoreFocusOut' to true

Signed-off-by: Yevhen Vydolob <[email protected]>

* Fix task yaml generator

Signed-off-by: Yevhen Vydolob <[email protected]>

Author: evidolob

src/model/pipeline/pipeline-model.ts

@@ -6,7 +6,7 @@
 import { TknElement, TknArray, TknBaseRootElement, NodeTknElement, TknStringElement, TknValueElement, TknParam, TknKeyElement } from '../common';
 import { TknElementType } from '../element-type';
 import { YamlMap, YamlSequence, YamlNode, isSequence } from '../../yaml-support/yaml-locator';
-import { pipelineYaml, getYamlMappingValue, findNodeByKey } from '../../yaml-support/tkn-yaml';
+import { pipelineYaml, getYamlMappingValue, findNodeByKey, findNodeAndKeyByKeyValue } from '../../yaml-support/tkn-yaml';
 import { EmbeddedTask } from './task-model';
 
 const ephemeralMap: YamlMap = {
@@ -229,9 +229,9 @@ export class PipelineTask extends NodeTknElement {
 
   get taskSpec(): EmbeddedTask {
     if (!this._taskSpec) {
-      const taskSpecNode = findNodeByKey<YamlSequence>('taskSpec', this.node as YamlMap)
+      const taskSpecNode = findNodeAndKeyByKeyValue<YamlNode, YamlSequence>('taskSpec', this.node as YamlMap)
       if (taskSpecNode) {
-        this._taskSpec = new EmbeddedTask(this, taskSpecNode);
+        this._taskSpec = new EmbeddedTask(this, taskSpecNode[0], taskSpecNode[1]);
       }
     }
     return this._taskSpec;

src/model/pipeline/task-model.ts

@@ -4,8 +4,8 @@
  *-----------------------------------------------------------------------------------------------*/
 
 import { findNodeByKey } from '../../yaml-support/tkn-yaml';
-import { YamlMap, YamlSequence } from '../../yaml-support/yaml-locator';
-import { NodeTknElement, TknArray, TknElement, TknStringElement } from '../common';
+import { YamlMap, YamlNode, YamlSequence } from '../../yaml-support/yaml-locator';
+import { NodeTknElement, TknArray, TknElement, TknKeyElement, TknStringElement } from '../common';
 import { TknElementType } from '../element-type';
 
 export class EmbeddedTask extends NodeTknElement {
@@ -23,6 +23,12 @@ export class EmbeddedTask extends NodeTknElement {
   // private _sidecars: TknArray<Sidecar>;
   // private _workspaces: TknArray<WorkspaceDeclaration>;
   private _results: TknArray<TaskResult>;
+  keyNode: TknElement
+
+  constructor(parent: TknElement, keyNode: YamlNode, node: YamlSequence) {
+    super(parent, node);
+    this.keyNode = new TknKeyElement(parent, keyNode);
+  }
 
   get results(): TknArray<TaskResult> {
     if (!this._results) {

src/util/tekton-vfs.ts

@@ -158,6 +158,24 @@ export class TektonVFSProvider implements FileSystemProvider {
     };
   }
 
+  async saveTektonDocument(doc: VirtualDocument): Promise<void | string> {
+    const tempPath = os.tmpdir();
+    const fsPath = path.join(tempPath, doc.uri.fsPath);
+    try {
+      await fsx.ensureFile(fsPath);
+      await fsx.writeFile(fsPath, doc.getText());
+  
+      const result = await this.updateK8sResource(fsPath);
+      if (result.error) {
+        return getStderrString(result.error);
+      }
+
+    } finally {
+      await fsx.unlink(fsPath);
+    }
+    
+  }
+
 }
 
 export const tektonVfsProvider = new TektonVFSProvider();

src/yaml-support/tkn-code-actions.ts

@@ -13,65 +13,70 @@ import * as jsYaml from 'js-yaml';
 import { Task } from '../tekton';
 import { telemetryLogError } from '../telemetry';
 import { ContextType } from '../context-type';
+import * as _ from 'lodash';
 
 interface ProviderMetadata {
   getProviderMetadata(): vscode.CodeActionProviderMetadata;
 }
 
-interface TaskInlineAction extends vscode.CodeAction{
+const INLINE_TASK = vscode.CodeActionKind.RefactorInline.append('TektonTask');
+const EXTRACT_TASK = vscode.CodeActionKind.RefactorExtract.append('TektonTask');
+
+interface InlineTaskAction extends vscode.CodeAction {
   taskRefStartPosition?: vscode.Position;
   taskRefEndPosition?: vscode.Position;
   taskRefName?: string;
   taskKind?: string;
   documentUri?: vscode.Uri;
 }
 
+function isTaskInlineAction(action: vscode.CodeAction): action is InlineTaskAction {
+  return action.kind.contains(INLINE_TASK);
+}
+
+interface ExtractTaskAction extends vscode.CodeAction {
+  documentUri?: vscode.Uri;
+  taskSpecText?: string;
+  taskSpecStartPosition?: vscode.Position;
+  taskSpecEndPosition?: vscode.Position;
+}
+
 class PipelineCodeActionProvider implements vscode.CodeActionProvider {
   provideCodeActions(document: vscode.TextDocument, range: vscode.Range | vscode.Selection): vscode.ProviderResult<vscode.CodeAction[]> {
     const result = [];
     const tknDocs = yamlLocator.getTknDocuments(document);
     for (const tknDoc of tknDocs) {
       const selectedElement = this.findTask(tknDoc, range.start);
       if (selectedElement) {
-        const taskRefName = selectedElement.taskRef?.name.value
-        if (!taskRefName){
-          continue;
+
+        const inlineAction = this.getInlineAction(selectedElement, document);
+        if (inlineAction) {
+          result.push(inlineAction);
+        }
+
+        const extractAction = this.getExtractTaskAction(selectedElement, document);
+        if (extractAction) {
+          result.push(extractAction);
         }
-        const action: TaskInlineAction = new vscode.CodeAction(`Inline '${taskRefName}' Task spec`, vscode.CodeActionKind.RefactorInline.append('TektonTask'));
-        const startPos = document.positionAt(selectedElement.taskRef?.keyNode?.startPosition);
-        const endPos = document.positionAt(selectedElement.taskRef?.endPosition);
-        action.taskRefStartPosition = startPos;
-        action.taskRefEndPosition = endPos;
-        action.taskRefName = taskRefName;
-        action.taskKind = selectedElement.taskRef?.kind.value;
-        action.documentUri = document.uri;
-        result.push(action);
       }
     }
 
     return result;
   }
-  resolveCodeAction?(codeAction: TaskInlineAction): Thenable<vscode.CodeAction> {
-    return vscode.window.withProgress({location: vscode.ProgressLocation.Notification, cancellable: false, title: `Loading '${codeAction.taskRefName}' Task...` }, async (): Promise<vscode.CodeAction> => {
-      const uri = tektonFSUri(codeAction.taskKind === TektonYamlType.ClusterTask ? ContextType.CLUSTERTASK : ContextType.TASK , codeAction.taskRefName, 'yaml');
-      try {
-        const taskDoc = await tektonVfsProvider.loadTektonDocument(uri, false);
-        codeAction.edit = new vscode.WorkspaceEdit();
-        codeAction.edit.replace(codeAction.documentUri,
-          new vscode.Range(codeAction.taskRefStartPosition, codeAction.taskRefEndPosition), 
-          this.extractTaskDef(taskDoc, codeAction.taskRefStartPosition.character, codeAction.taskRefEndPosition.character));
-      } catch (err){
-        vscode.window.showErrorMessage('Cannot get Tekton Task definition: ' + err.toString());
-        telemetryLogError('resolveCodeAction', `Cannot get '${codeAction.taskRefName}' Task definition`);
-      }
-      return codeAction;
-    });
+  resolveCodeAction?(codeAction: vscode.CodeAction): Thenable<vscode.CodeAction> {
+    if (isTaskInlineAction(codeAction)){
+      return this.resolveInlineAction(codeAction);
+    }
+
+    if (codeAction.kind.contains(EXTRACT_TASK)) {
+      return this.resolveExtractTaskAction(codeAction);
+    }
 
   }
 
   getProviderMetadata(): vscode.CodeActionProviderMetadata {
     return {
-      providedCodeActionKinds: [vscode.CodeActionKind.RefactorInline.append('TektonTask')],
+      providedCodeActionKinds: [INLINE_TASK, EXTRACT_TASK],
     }
   }
 
@@ -97,6 +102,137 @@ class PipelineCodeActionProvider implements vscode.CodeActionProvider {
 
   }
 
+  private getInlineAction(selectedElement: PipelineTask, document: vscode.TextDocument): InlineTaskAction | undefined {
+    const taskRefName = selectedElement.taskRef?.name.value
+    if (!taskRefName){
+      return;
+    }
+    const action: InlineTaskAction = new vscode.CodeAction(`Inline '${taskRefName}' Task spec`, INLINE_TASK);
+    const startPos = document.positionAt(selectedElement.taskRef?.keyNode?.startPosition);
+    const endPos = document.positionAt(selectedElement.taskRef?.endPosition);
+    action.taskRefStartPosition = startPos;
+    action.taskRefEndPosition = endPos;
+    action.taskRefName = taskRefName;
+    action.taskKind = selectedElement.taskRef?.kind.value;
+    action.documentUri = document.uri;
+
+    return action;
+  }
+
+  private async resolveInlineAction(codeAction: InlineTaskAction): Promise<InlineTaskAction> {
+    return vscode.window.withProgress({location: vscode.ProgressLocation.Notification, cancellable: false, title: `Loading '${codeAction.taskRefName}' Task...` }, async (): Promise<vscode.CodeAction> => {
+      const uri = tektonFSUri(codeAction.taskKind === TektonYamlType.ClusterTask ? ContextType.CLUSTERTASK : ContextType.TASK , codeAction.taskRefName, 'yaml');
+      try {
+        const taskDoc = await tektonVfsProvider.loadTektonDocument(uri, false);
+        codeAction.edit = new vscode.WorkspaceEdit();
+        codeAction.edit.replace(codeAction.documentUri,
+          new vscode.Range(codeAction.taskRefStartPosition, codeAction.taskRefEndPosition), 
+          this.extractTaskDef(taskDoc, codeAction.taskRefStartPosition.character, codeAction.taskRefEndPosition.character));
+      } catch (err){
+        vscode.window.showErrorMessage('Cannot get Tekton Task definition: ' + err.toString());
+        telemetryLogError('resolveCodeAction', `Cannot get '${codeAction.taskRefName}' Task definition`);
+      }
+      return codeAction;
+    });
+  }
+
+  private getExtractTaskAction(selectedElement: PipelineTask, document: vscode.TextDocument): ExtractTaskAction | undefined {
+    const taskSpec = selectedElement.taskSpec;
+    if (!taskSpec) {
+      return;
+    }
+    const startPos = document.positionAt(taskSpec.keyNode?.startPosition);
+    let taskSpecStartPos = document.positionAt(taskSpec.startPosition);
+    // start replace from stat of the line
+    taskSpecStartPos = document.lineAt(taskSpecStartPos.line).range.start;
+    let endPos = document.positionAt(taskSpec.endPosition);
+
+    // if last line is contains only spaces then replace til previous line
+    const lastLine = document.getText(new vscode.Range(endPos.line, 0, endPos.line, endPos.character));
+    if (lastLine.trim().length === 0) {
+      endPos = document.lineAt(endPos.line - 1).range.end;
+    }
+
+    const action: ExtractTaskAction = new vscode.CodeAction(`Extract '${selectedElement.name.value}' Task spec`, EXTRACT_TASK);
+    action.documentUri = document.uri;
+    action.taskSpecStartPosition = startPos;
+    action.taskSpecEndPosition = endPos;
+    action.taskSpecText = document.getText(new vscode.Range(taskSpecStartPos, endPos));
+
+    return action;
+  }
+
+  private async resolveExtractTaskAction(action: ExtractTaskAction): Promise<vscode.CodeAction> {
+    const name = await vscode.window.showInputBox({ignoreFocusOut: true, prompt: 'Provide Task Name' });
+    const type = await vscode.window.showQuickPick(['Task', 'ClusterTask'], {placeHolder: 'Select Task Type:', canPickMany: false, ignoreFocusOut: true});
+    if (!type || !name) {
+      return;
+    }
+    return vscode.window.withProgress({location: vscode.ProgressLocation.Notification, cancellable: false, title: 'Extracting Task...' }, async (): Promise<vscode.CodeAction> => {
+      try {
+        const virtDoc = this.getDocForExtractedTask(name, type, action.taskSpecText);
+        const saveError = await tektonVfsProvider.saveTektonDocument(virtDoc);
+        if (saveError) {
+          console.error(saveError);
+          throw new Error(saveError);
+        }
+        const newUri = tektonFSUri(type, name, 'yaml');
+        await vscode.commands.executeCommand('vscode.open', newUri);
+        const indentation = ' '.repeat(action.taskSpecStartPosition.character);
+        action.edit = new vscode.WorkspaceEdit();
+        action.edit.replace(action.documentUri, new vscode.Range(action.taskSpecStartPosition, action.taskSpecEndPosition),
+          `taskRef:
+  ${indentation}name: ${name}
+  ${indentation}kind: ${type}`);
+      } catch (err) {
+        console.error(err);
+      }
+      
+      return action;
+    });
+  }
+
+  private getDocForExtractedTask(name: string, type: string, content: string): VirtualDocument {
+
+    const lines = content.split('\n');
+    const firstLine = lines[0].trimLeft();
+    const indentation = lines[0].length - firstLine.length;
+    lines[0] = firstLine;
+    for (let i = 1; i < lines.length; i++) {
+      lines[i] = lines[i].slice(indentation);
+    }
+    content = lines.join('\n');
+
+    const taskPart = jsYaml.load(content);
+    let metadataPart: {} = undefined;
+    if (taskPart.metadata) {
+      metadataPart = taskPart.metadata;
+      delete taskPart['metadata'];
+    }
+
+    let metadataPartStr: string = undefined;
+    if (metadataPart && !_.isEmpty(metadataPart)) {
+      metadataPartStr = jsYaml.dump(metadataPart, {indent: 2});
+      metadataPartStr = metadataPartStr.trimRight().split('\n').map(it => '  ' + it).join('\n');
+    }
+    let specContent = jsYaml.dump(taskPart, {indent: 2, noArrayIndent: false});
+    specContent = specContent.trimRight().split('\n').map(it => '  ' + it).join('\n');
+    return {
+      version: 1,
+      uri: vscode.Uri.file(`file:///extracted/task/${name}.yaml`),
+      getText: () => {
+        return `apiVersion: tekton.dev/v1beta1
+kind: ${type}
+metadata:
+  name: ${name}\n${metadataPartStr ? metadataPartStr : ''}
+spec:
+${specContent}
+`;
+      }
+    }
+
+  }
+
   private extractTaskDef(taskDoc: VirtualDocument, startPos: number, endPos): string {
     const task: Task = jsYaml.safeLoad(taskDoc.getText()) as Task;
     if (!task){

test/text-document-mock.ts

@@ -15,7 +15,7 @@ export class TestTextDocument implements vscode.TextDocument {
   isDirty: boolean;
   isClosed: boolean;
 
-  private text;
+  private text: string;
 
   constructor(public uri: vscode.Uri, text: string) {
     this.text = text.replace(/\r\n/gm, '\n'); // normalize end of line
@@ -27,11 +27,34 @@ export class TestTextDocument implements vscode.TextDocument {
   eol = vscode.EndOfLine.LF;
   lineCount: number;
 
+  private get lines(): string[] {
+    return this.text.split('\n');
+  }
+
   lineAt(position: number | vscode.Position): vscode.TextLine {
-    throw new Error('Method not implemented.');
+    const line = typeof position === 'number' ? position : position.line
+    const text = this.lines[line];
+    return {
+      text,
+      range: new vscode.Range(line, 0, line, text.length)
+    } as vscode.TextLine;
   }
+  
   offsetAt(position: vscode.Position): number {
-    throw new Error('Method not implemented.');
+    const lines = this.text.split('\n');
+    let currentOffSet = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const l = lines[i];
+      if (position.line === i) {
+        if (l.length < position.character) {
+          throw new Error(`Position ${JSON.stringify(position)} is out of range. Line [${i}] only has length ${l.length}.`);
+        }
+        return currentOffSet + position.character;
+      } else {
+        currentOffSet += l.length + 1;
+      }
+    }
+    throw new Error(`Position ${JSON.stringify(position)} is out of range. Document only has ${lines.length} lines.`);
   }
 
   positionAt(offset: number): vscode.Position {
@@ -48,7 +71,11 @@ export class TestTextDocument implements vscode.TextDocument {
     throw new Error('Cannot find position!');
   }
   getText(range?: vscode.Range): string {
-    return this.text;
+    if (!range)
+      return this.text;
+    const offset = this.offsetAt(range.start);
+    const length = this.offsetAt(range.end) - offset;
+    return this.text.substr(offset, length);
   }
   getWordRangeAtPosition(position: vscode.Position, regex?: RegExp): vscode.Range {
     throw new Error('Method not implemented.');