Ace: कोड परिवर्तन के रूप में ब्रेकप्वाइंट ले जाएँ।

Cloud9 में हमने एक अलग सरणी में ब्रेकप्वाइंट अपडेट करने के लिए चेंज श्रोता का उपयोग किया https://github.com/ajaxorg/cloud9/blob/master/plugins-client/ext.debugger/breakpoints.js#L170

चूंकि ऐस स्ट्रिंग्स की सरणी का उपयोग करता है, मुझे यकीन नहीं है कि लाइन हैंडल को सर्वोत्तम तरीके से कैसे कार्यान्वित किया जाए, या तो लाइनों के साथ सिंक में रखी गई वस्तुओं की पूरी सरणी, या एडिट_सेशन में फोल्डलाइन के प्रबंधन के समान श्रेणियों का उपयोग करें। मुश्किल हिस्सा उन लाइनों को संभालना है जिन्हें विभाजित या विलय किया जा रहा है, क्योंकि विभिन्न प्रकार की लाइन एनोटेशन के लिए अलग-अलग व्यवहार की आवश्यकता होती है।

मेरा मानना ​​है कि ब्रेकप्वाइंट के लिए आपका समाधान एनोटेशन के लिए अच्छा काम करेगा।

मुश्किल हिस्सा उन लाइनों को संभालना है जिन्हें विभाजित या विलय किया जा रहा है, क्योंकि विभिन्न प्रकार की लाइन एनोटेशन के लिए अलग> व्यवहार की आवश्यकता होती है।

हम्म.. मैं एक भी उदाहरण नहीं बना सकता। अगर आप कुछ साझा करते हैं तो मैं इसकी सराहना करता हूं :)

मुझे एक समाधान मिला लेकिन यह केवल मेरे मामले में काम करता है क्योंकि मैं एक बार में केवल एक ब्रेकपॉइंट की अनुमति देता हूं। कुछ सुधार के साथ सामान्य मामले के लिए भी फिट हो सकता है।
मैंने संपादक उदाहरण पर परिवर्तन श्रोता का उपयोग किया और घटना को निकालने वाली कार्रवाई द्वारा संशोधित लाइनों की संख्या की जांच की। यदि ये एक से अधिक हैं तो हम उस स्थिति में हैं जब एक या अधिक पंक्तियाँ जोड़ी या हटाई जाती हैं। घटना का क्रिया पैरामीटर हमें यह समझने में मदद करता है कि हम किस मामले में हैं।
यह देखने के लिए कि क्या मुझे ब्रेकपॉइंट को स्थानांतरित करना है, मैं जांचता हूं कि संशोधन की प्रारंभिक और समाप्ति पंक्ति के बीच है या नहीं। अगर यह इस सीमा में है तो मुझे आगे बढ़ना होगा।

कोड (जल्दी से लिखा गया) निम्नलिखित है:

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);
                            }
                        }
                    }
                }
            });

आशा है कि किसी ने मदद की होगी!

मैंने कई ब्रेकपॉइंट्स के लिए काम करने के लिए उपरोक्त एलेसेंड्रोकैप्रारेली के समाधान को संशोधित किया, दूसरों के लिए सहायक हो सकता है:

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);
        }
    }
})