Ace: Verschieben Sie Haltepunkte, wenn sich der Code ändert.

In Cloud9 haben wir Change Listener verwendet, um Breakpoints in einem separaten Array zu aktualisieren https://github.com/ajaxorg/cloud9/blob/master/plugins-client/ext.debugger/breakpoints.js#L170

Da ace ein Array von Strings verwendet, bin ich mir nicht sicher, wie ich Zeilenhandles am besten implementieren soll, entweder ein vollständiges Array von Objekten, die mit den Zeilen synchron gehalten werden, oder Bereiche verwenden, die der Behandlung von Faltlinien in edit_session ähneln. Ein kniffliger Teil ist die Handhabung von Linien, die geteilt oder zusammengeführt werden, da verschiedene Arten von Linienanmerkungen ein unterschiedliches Verhalten erfordern.

Ich glaube, dass Ihre Lösung für Haltepunkte gut für Anmerkungen funktionieren würde.

Ein kniffliger Teil ist der Umgang mit Linien, die geteilt oder zusammengeführt werden, da verschiedene Arten von Linienanmerkungen ein unterschiedliches Verhalten erfordern.

Hmm.. Ich kann mir kein einziges Beispiel ausdenken. Ich würde mich freuen, wenn du welche teilst :)

Ich habe eine Lösung gefunden, aber sie funktioniert nur in meinem Fall, weil ich nur einen Haltepunkt gleichzeitig zulasse. Mit einigen Verbesserungen kann es auch für den allgemeinen Fall passen.
Ich habe den On-Change-Listener auf der Editor-Instanz verwendet und die Anzahl der Zeilen überprüft, die durch die Aktion geändert wurden, die das Ereignis ausgelöst hat. Wenn dies mehr als eine ist, sind wir in dem Fall, wenn eine oder mehrere Zeilen hinzugefügt oder entfernt werden. Der Aktionsparameter des Ereignisses hilft uns zu verstehen, in welchem ​​​​Fall wir uns befinden.
Um zu sehen, ob ich die Haltepunkte verschieben muss, überprüfe ich, ob sie zwischen der Start- und Endzeile der Änderung liegen. Wenn es in diesem Bereich ist, muss ich umziehen.

Der Code (schnell geschrieben) lautet wie folgt:

aceEditor.on("change", function (e) {
                var breakpointsArray = aceEditor.session.getBreakpoints();
                if(Object.keys(aceEditor.session.getBreakpoints()).length>0){
                    if(e.lines.length>1){
                        var breakpoint = parseInt(Object.keys(breakpointsArray)[0]);
                        var lines = e.lines.length -1;
                        var start = e.start.row;
                        var end = e.end.row;
                        if(e.action==='insert'){
                            console.log('new lines',breakpoint, start , end );
                            if(breakpoint>start ){
                                console.log('breakpoint forward');
                                aceEditor.session.clearBreakpoint(breakpoint);
                                aceEditor.session.setBreakpoint(breakpoint + lines);
                            }
                        } else if(e.action==='remove'){
                            console.log('removed lines',breakpoint, start , end);
                            if(breakpoint>start && breakpoint<end ){
                                console.log('breakpoint remove');
                                aceEditor.session.clearBreakpoint(breakpoint);
                            }
                            if(breakpoint>=end ){
                                console.log('breakpoint behind');
                                aceEditor.session.clearBreakpoint(breakpoint);
                                aceEditor.session.setBreakpoint(breakpoint - lines);
                            }
                        }
                    }
                }
            });

Hoffe jemandem geholfen zu haben!

Ich habe die Lösung von alessandrocaprarelli oben so geändert, dass sie für mehrere Haltepunkte funktioniert. Dies kann für andere hilfreich sein:

editor.on("change", function (e) {
    if (e.lines.length > 1 && (e.action==='insert' || e.action==='remove')){
        const breakpointsArrayOld = editor.session.getBreakpoints();
        let breakpointsArrayNew = [];

        const amountOfLinesAffected = e.lines.length - 1;
        const startRow = e.start.row;
        const endRow = e.end.row;

        for (const key of Object.keys(breakpointsArrayOld)) {
            let breakpointRow = parseInt(key)

            if (e.action==='insert') {  // new lines
                if (breakpointRow > startRow ){
                    // breakpoint forward
                    breakpointsArrayNew[breakpointRow + amountOfLinesAffected] = "ace_breakpoint"
                }
                else {
                    // unaffected by insert
                    breakpointsArrayNew[breakpointRow] = "ace_breakpoint"
                }
            }
            else if (e.action==='remove') {  // removed lines
                if (breakpointRow > startRow && breakpointRow <= endRow ){
                    // breakpoint removed
                }
                else if (breakpointRow >= endRow ){
                    // breakpoint behind
                    breakpointsArrayNew[breakpointRow - amountOfLinesAffected] = "ace_breakpoint"
                }
                else {
                    // unaffected by remove
                    breakpointsArrayNew[breakpointRow] = "ace_breakpoint"
                }
            }
        }

        // remove all old breakpoints
        for (const key of Object.keys(breakpointsArrayOld)) {
            let breakpointRow = parseInt(key)
            editor.session.clearBreakpoint(breakpointRow);
        }

        // add all new breakpoints
        for (const key of Object.keys(breakpointsArrayNew)) {
            let breakpointRow = parseInt(key)
            editor.session.setBreakpoint(breakpointRow);
        }
    }
})