vscode-go-adjust/src/extension.ts

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below

import * as vscode from 'vscode';
import { Provider } from './codeAction';

class StructInfo {
    ShorthandName: string;
    Name: string;
    Range: number[];
    Fields: Map<string, Field>;

    constructor(name: string, fields: Field[], range: number[]) {
        this.Name = name;

        var sname: string = "";
        sname += this.Name[0].toLowerCase();
        for (let i = 1; i < this.Name.length; i++) {
            let c = this.Name.charCodeAt(i);
            if (c <= 90 && c >= 65) {
                sname += this.Name[i].toLowerCase();
            }
        }

        this.ShorthandName = this.Name;
        this.Range = range;

        this.Fields = new Map<string, Field>();
        fields.forEach((value) => {
            this.Fields.set(value.Key, value);
        });
    }

    getFieldsString(): string[] {
        var result: string[] = [];

        this.Fields.forEach((field, index) => {
            result.push(this.Name + field.toString());
        });

        return result;
    }
}

class Field {
    Parent: string;
    Type: string;
    Name: string;
    Range: number[];
    Key: string;

    constructor(parent: string, type: string, name: string, range: number[]) {
        this.Parent = parent;
        this.Type = type;
        this.Name = name;
        this.Range = range;
        
        this.Key = (this.Parent.substr(1) + this.Name[0].toUpperCase() + this.Name.substr(1)).replace(new RegExp("\\.", "g"), "");
        // TODO: 大小写Map的问题
    }

    toString(): string {
        return this.Parent.substr(1) + this.Name + " " + this.Type;
    }
}

let typeMap = new Map<string, GeneratorType>() ;
let typeCharMap = new Map<GeneratorType, string>() ;

// this method is called when your extension is activated
// your extension is activated the very first time the command is executed
function activate(context: vscode.ExtensionContext) {
    // Use the console to output diagnostic information (console.log) and errors (console.error)
    // This line of code will only be executed once when your extension is activated
    console.log('Congratulations, your extension "go-quickly-generator" is now active!');
 
    
    typeMap.set("Getter",  GeneratorType.Getter);
    typeMap.set("Setter",  GeneratorType.Setter);
    typeCharMap.set(GeneratorType.Getter, "G");
    typeCharMap.set(GeneratorType.Setter, "S");
    typeCharMap.set(GeneratorType.Getter | GeneratorType.Setter, "GS");
    

    context.subscriptions.push(vscode.commands.registerCommand('Go-Quickly-Generator.Go-Gen-GetSet', () => {
        // The code you place here will be executed every time your command is executed
        // Display a message box to the user
        let sinfo = GetStruct();
        if(sinfo) {
           
            vscode.window.showQuickPick(["Getter", "Setter"], <vscode.QuickPickOptions>{canPickMany: true, placeHolder: "select generator type getter or setter"}).then( items => {
                console.log(items);
                let myitems = items as any as string[];
                let t = GeneratorType.Unknown;
                myitems.forEach((value)=>{
                    let sel = typeMap.get(value);
                    if(sel) {
                        t = t | sel;
                    }
                });
                if(sinfo) {
                    GeneratorSetGet(sinfo, t);
                }
            });
            // GeneratorSetGet(sinfo, GeneratorType.Getter | GeneratorType.Setter);
        } else {
            vscode.window.showErrorMessage("there is no struct(go) to focus. you can move point to struct(go)");
        }
    }));

    // context.subscriptions.push(vscode.languages.registerCodeActionsProvider(
    //     "go", new Provider(), { providedCodeActionKinds: [vscode.CodeActionKind.Source] }
    // ));


    context.subscriptions.push(vscode.commands.registerCommand('Go-Quickly-Generator.Getter', function () {
        let editor = vscode.window.activeTextEditor;
        if (editor !== undefined) {
            const currentPos = editor.selection.active;
            const lineCount = editor.document.lineCount;
            // let selection = editor.selection;
            // let lineText = editor.document.lineAt(selection.active);
            // vscode.window.showInformationMessage( lineText.text );
        }
    }));
}

function getAbbreviation(name: string): string | undefined {
    if (name.length) {
        let shortName = name[0].toLowerCase();
        let m = name.substr(1).match("[A-Z]");
        if (m) {
            m.forEach((v) => {
                shortName += v.toLowerCase();
            });
            return shortName;
        }
    }
    return undefined;
}

enum GeneratorType {
    Unknown = 0 ,
    Setter  = 1 << 0,
    Getter  = 1 << 1,
}

function GeneratorSetGet(sinfo: StructInfo, stype: GeneratorType) {

        console.log(sinfo);

        let editor = vscode.window.activeTextEditor;
        if (editor !== undefined) {

            let gtypechar = typeCharMap.get(stype) as string;
            let regexFunction = `^func {0,}\\(.+${sinfo.Name} {0,}\\) {0,}[${gtypechar}]et([a-zA-Z_]+) {0,}\\(`;
            // console.log(regexFunction);
            let existsStructFunctions: Set<string> = new Set<string>();
            for (let n = 0; n < editor.document.lineCount; n++) {
                let line = editor.document.lineAt(n);
                let matches = line.text.match(regexFunction);
                if (matches !== null) {
                    existsStructFunctions.add(matches[1]);
                }
            }

            const options = <vscode.QuickPickOptions>{ canPickMany: true, placeHolder: "select the fields that would be generator get set" };
            var items: vscode.QuickPickItem[] = [];
            var obj = {
                info: sinfo,
                exists: existsStructFunctions,
                items: function () {
                    this.info.Fields.forEach((value, key) => {
                        if (this.exists.has(key)) {
                            vscode.window.showInformationMessage("Get" + key + " or Set" + key + " is Exists");
                        } else {
                            items.push(<vscode.QuickPickItem>{
                                label: value.toString(),
                                detail: this.info.Name,
                                description: key,
                            });
                        }
                    });
                },

                pick: function () {
                    this.items();
                    vscode.window.showQuickPick(items, options).then((item) => {
                        if (item) {
                            let fields = item as any as vscode.QuickPickItem[];
                            let sname = getAbbreviation(this.info.Name) as string;
                            let structString = `func (${sname} *${this.info.Name})`;

                            fields.forEach((qitem) => {
                                let field = this.info.Fields.get(qitem.description as string);
                                if (field) {
  
                                    let editor = vscode.window.activeTextEditor;
                                    if (editor) {

                                        let keyName = field.Name[0].toUpperCase() + field.Name.substr(1);
                                        let funcitonName = field.Parent.replace( new RegExp("\\.", "g"), "") + keyName ;

                                        // Set
                                        if(stype & GeneratorType.Setter) {
                                            let prefix = "Set";
                                            let setFunction = prefix + funcitonName ;
                                            let params = `(${field.Name} ${field.Type})`;
                                            let comment = `// ${setFunction} ${prefix} ${field.Name} ${field.Type}\n`;
                                            let ss = new vscode.SnippetString(`\n${comment}${structString} ${setFunction}${params} {\n\t${sname}${field.Parent}${field.Name} = ${field.Name}\n}\n`);
                                            editor.insertSnippet(ss, new vscode.Position(this.info.Range[1] + 1, 0));
                                        }

                                        if(stype & GeneratorType.Getter) {
                                            let prefix = "Get";
                                            let getFunction = prefix + funcitonName ;
                                            let comment = `// ${getFunction} ${prefix} return ${field.Name} ${field.Type}\n`;
                                            let ss = new vscode.SnippetString(`\n${comment}${structString} ${getFunction}() ${field.Type} {\n\treturn ${sname}${field.Parent}${field.Name}\n}\n`);
                                            editor.insertSnippet(ss, new vscode.Position(this.info.Range[1] + 1, 0)); 
                                        }
                                    }
                                }
                            });
                        }
                    });
                }
            };

            obj.pick();
        }
}

function GetStruct(): StructInfo | undefined {
    let editor = vscode.window.activeTextEditor;
    if (editor !== undefined) {
        if (editor.document.languageId !== 'go') {
            vscode.window.showInformationMessage('file in the active editor is not a go file(*.go)');
            return;
        }
        let selection = editor.selection;
        // vscode.window.showInformationMessage( editor.document.version.toString() );
        // vscode.window.showInformationMessage( text );
        let selectline = selection.active.line;
        let regex = "type +([^ ]+) +struct";
        // lineText.text.match()
        for (let i = selectline; i >= 0; i--) {
            let lineText = editor.document.lineAt(i);
            let matchs = lineText.text.match(regex);
            if (matchs !== null) {
                let open = 0;
                BREAK_OPEN: for (let n = i; n < editor.document.lineCount; n++) {
                    let lineText = editor.document.lineAt(n);
                    for (let c = 0; c < lineText.text.length; c++) {
                        switch (lineText.text[c]) {
                            case '{':
                                open++;
                                break;
                            case '}':
                                open--;
                                if (open === 0) {
                                    if (n >= selectline) {
                                        let structName = matchs[1];
                                        return new StructInfo(structName, getStructField(editor, "", i, n), [i, n]);
                                    }
                                    break BREAK_OPEN;
                                }
                                break;
                        }
                    }
                }
                break;
            }
        }
    }
}

exports.activate = activate;
function getStructField(editor: vscode.TextEditor, parent: string, startline: number, endline: number): Field[] {

    let result: Field[] = [];

    if (endline - startline <= 1) {
        return result;
    }

    parent += ".";

    let regex = "([^ \t]+)[ \t]+([^ \\(\\{\t]+)";
    for (let i = startline + 1; i < endline; i++) {
        let textline = editor.document.lineAt(i);
        let matchArray = textline.text.match(regex);

        if (matchArray !== null) {
            var end: number;
            let fieldName = matchArray[matchArray.length - 2];
            let fieldType = matchArray[matchArray.length - 1].trim();

            switch (fieldType) {
                case 'struct':
                    end = getFieldRange(editor, ['{', '}'], i, endline);
                    if (i === end) {
                        // let matches = textline.text.match("struct {0,}\\{[^ \t]+\\}");
                        function getSingleStructRelationship(source: string, parent: string): Field | undefined {
                            let smatch = source.match("([^ \t]+)[^s]+struct {0,}\\{(.+)\\}");
                            if (smatch !== null) {
                                // console.log(smatch[0], smatch[1], smatch[2]);
                                return getSingleStructRelationship(smatch[2], parent + "." + smatch[1]);
                            } else {
                                smatch = source.match("([^ \t]+)[ \t]+(.+)");
                                if (smatch !== null) {
                                    return new Field(parent + ".", smatch[2].trim(), smatch[1], [i, end]);
                                }
                            }
                        }

                        let v = getSingleStructRelationship(textline.text, "");
                        if (v !== undefined) {
                            result.push(v);
                        }
                    } else {
                        result = result.concat(getStructField(editor, parent + fieldName, i, end));
                        i = end;
                    }
                    break;
                case 'interface':
                    result.push(new Field(parent, fieldType + "{}", fieldName, [i, i]));
                    break;
                case 'func':
                    end = getFieldRange(editor, ['(', ')'], i, endline);
                    if (i === end) {
                        let matches = textline.text.match("func\\(.+");
                        if (matches !== null) {
                            result.push(new Field(parent, matches[0].trim(), fieldName, [i, end]));
                        }
                    } else {
                        i = end;
                    }
                    break;
                default:
                    result.push(new Field(parent, fieldType, fieldName, [i, i]));
                    break;
            }
        }
    }

    return result;
}

function getFieldRange(editor: vscode.TextEditor, pair: string[], startline: number, endline: number): number {

    let open = 0;
    let start = startline;
    let end = startline;

    BREAK_OPEN: for (let n = start; n < endline; n++) {
        let lineText = editor.document.lineAt(n);
        for (let c = 0; c < lineText.text.length; c++) {
            switch (lineText.text[c]) {
                case pair[0]:
                    open++;
                    break;
                case pair[1]:
                    open--;
                    if (open === 0) {
                        end = n;
                        break BREAK_OPEN;
                    }
                    break;
            }
        }
    }

    return end;
}


// export function getStruct(editor: vscode.TextEditor) {
// }
// this method is called when your extension is deactivated
function deactivate() { }
exports.deactivate = deactivate;