integration of code-folding extension into brackets

src/extensions/default/CodeFolding/Prefs.js

@@ -0,0 +1,127 @@
+/**
+ * Wrapper around brackets pref system to ensure preferences are stored in in one single object instead of using multiple keys.
+ * This is to make it easy for the user who edits their preferences file to easily manage the potentially numerous lines of preferences generated by the persisting code-folding state.
+ * @author Patrick Oladimeji
+ * @date 3/22/14 20:39:53 PM
+ */
+/*jslint vars: true, plusplus: true, devel: true, nomen: true, indent: 4, maxerr: 50 */
+/*global define, brackets*/
+define(function (require, exports, module) {
+    "use strict";
+    var PreferencesManager      = brackets.getModule("preferences/PreferencesManager"),
+        prefs                   = PreferencesManager.getExtensionPrefs("code-folding"),
+        strings                 = brackets.getModule("strings"),
+        store                   = {},
+        foldsKey                = "folds";
+
+    //default preference values
+    prefs.definePreference("enabled", "boolean", true,
+                           {name: strings.ENABLE_CODE_FOLDING, description: strings.ENABLE_CODE_FOLDING});
+    prefs.definePreference("minFoldSize", "number", 2,
+                           {name: strings.MIN_FOLD_SIZE, description: strings.MIN_FOLD_SIZE_HELP});
+    prefs.definePreference("saveFoldStates", "boolean", true,
+                           {name: strings.SAVE_FOLD_STATES, description: strings.SAVE_FOLD_STATES_HELP});
+    prefs.definePreference("alwaysUseIndentFold", "boolean", true,
+                           {name: strings.ALWAYS_USE_INDENT_FOLD, description: strings.ALWAYS_USE_INDENT_FOLD_HELP});
+    prefs.definePreference("enableRegionFolding", "boolean", true,
+                           {name: strings.ENABLE_REGION_FOLDING, description: strings.ENABLE_REGION_FOLDING});
+    prefs.definePreference("fadeFoldButtons", "boolean", false,
+                           {name: strings.FADE_FOLD_BUTTONS, description: strings.FADE_FOLD_BUTTONS_HELP});
+    prefs.definePreference("maxFoldLevel", "number", 2,
+                           {name: strings.MAX_FOLD_LEVEL, description: strings.MAX_FOLD_LEVEL_HELP});
+    prefs.definePreference("folds", "object", {});
+
+    /**
+        Simplifies the fold ranges into an array of pairs of numbers.
+        @param {!{number: {from: {ch, line}, to: {ch, line}} folds the raw fold ranges indexed by line numbers
+        @returns {number: Array<Array<number>>} an object whose keys are line numbers and the values are array
+        of two 2-element arrays. First array contains [from.line, from.ch] and the second contains [to.line, to.ch]
+    */
+    function simplify(folds) {
+        if (!folds) {
+            return;
+        }
+        var res = {}, range;
+        Object.keys(folds).forEach(function (line) {
+            range = folds[line];
+            res[line] = Array.isArray(range) ? range : [[range.from.line, range.from.ch], [range.to.line, range.to.ch]];
+        });
+        return res;
+    }
+    /**
+        Inflates the fold ranges stored as simplified numeric arrays. The inflation converts the data into
+        objects whose keys are line numbers and whose values are objects in the format {from: {line, ch}, to: {line, ch}}.
+        @param {number: Array<Array<number>>}  folds the simplified fold ranges
+        @returns {number: {from: {line, ch}, to: {line, ch}}}
+    */
+    function inflate(folds) {
+        if (!folds) {
+            return;
+        }
+         //transform the folds into objects with from and to properties
+        var ranges = {}, obj;
+        Object.keys(folds).forEach(function (line) {
+            obj = folds[line];
+            ranges[line] = {from: {line: obj[0][0], ch: obj[0][1]}, to: {line: obj[1][0], ch: obj[1][1]}};
+        });
+
+        return ranges;
+    }
+
+    /**
+        Gets the line folds saved for the specified path.
+        @param {string} path the document path
+        @returns {number: {from: {line, ch}, to: {line, ch}}} the line folds for the document at the specified path
+    */
+    function get(path) {
+        store = (prefs.get(foldsKey) || {});
+        return inflate(store[path]);
+    }
+
+    /**
+        Saves the line folds specified
+    */
+    function set(path, folds) {
+        store[path] = simplify(folds);
+        prefs.set(foldsKey, store);
+    }
+
+    /**
+        Get the code folding setting with the specified key from the store
+        @param {!string} key The key for the setting to retrieve
+        @returns {string} the setting with the specified key
+    */
+    function getSetting(key) {
+        return prefs.get(key, PreferencesManager.CURRENT_PROJECT);
+    }
+
+    /**
+        Gets all the values for code folding settings.
+        @returns {object} all settings saved in the preferences.
+    */
+    function getAllSettings() {
+        var res = {};
+        prefs.getKeys().forEach(function (key) {
+            res[key] = getSetting(key);
+        });
+        return res;
+    }
+
+    /**
+        Clears all the saved line folds for all documents.
+    */
+    function clearAllFolds() {
+        prefs.set(foldsKey, {});
+    }
+
+    module.exports.get = get;
+
+    module.exports.set = set;
+
+    module.exports.getSetting = getSetting;
+
+    module.exports.getAllSettings = getAllSettings;
+
+    module.exports.clearAllFolds = clearAllFolds;
+
+});

src/extensions/default/CodeFolding/foldhelpers/foldcode.js

@@ -0,0 +1,226 @@
+/**
+ * Based on http://codemirror.net/addon/fold/foldcode.js
+ * @author Patrick Oladimeji
+ * @date 10/28/13 8:41:46 AM
+ * @last modified 20 April 2014
+ */
+/*jslint vars: true, plusplus: true, devel: true, nomen: true, indent: 4, maxerr: 50 */
+/*global define, brackets, document*/
+define(function (require, exports, module) {
+    "use strict";
+    var CodeMirror          = brackets.getModule("thirdparty/CodeMirror2/lib/codemirror"),
+        prefs               = require("Prefs");
+
+    function doFold(cm, pos, options, force) {
+        options = options || {};
+        force = force || "fold";
+        if (typeof pos === "number") {
+            pos = CodeMirror.Pos(pos, 0);
+        }
+        var finder = options.rangeFinder || CodeMirror.fold.auto;
+        var minSize = options.minFoldSize || prefs.getSetting("minFoldSize");
+
+        function getRange(allowFolded) {
+            var range = options.range || finder(cm, pos);
+            if (!range || range.to.line - range.from.line < minSize) {
+                return null;
+            }
+            var marks = cm.findMarksAt(range.from),
+                i,
+                lastMark,
+                foldMarks;
+            for (i = 0; i < marks.length; ++i) {
+                if (marks[i].__isFold && force !== "fold") {
+                    if (!allowFolded) {
+                        return null;
+                    }
+                    range.cleared = true;
+                    marks[i].clear();
+                }
+            }
+            //check for overlapping folds
+            if (marks && marks.length) {
+                foldMarks = marks.filter(function (d) {
+                    return d.__isFold;
+                });
+                if (foldMarks && foldMarks.length) {
+                    lastMark = foldMarks[foldMarks.length - 1].find();
+                    if (lastMark && range.from.line <= lastMark.to.line && lastMark.to.line < range.to.line) {
+                        return null;
+                    }
+                }
+            }
+            return range;
+        }
+
+        function makeWidget() {
+            var widget = document.createElement("span");
+            widget.className = "CodeMirror-foldmarker";
+            return widget;
+        }
+
+        var range = getRange(true);
+        if (options.scanUp) {
+            while (!range && pos.line > cm.firstLine()) {
+                pos = CodeMirror.Pos(pos.line - 1, 0);
+                range = getRange(false);
+            }
+        }
+        if (!range || range.cleared || force === "unfold" || range.to.line - range.from.line < minSize) {
+            if (range) { range.cleared = false; }
+            return;
+        }
+
+        var myWidget = makeWidget();
+        var myRange = cm.markText(range.from, range.to, {
+            replacedWith: myWidget,
+            clearOnEnter: true,
+            __isFold: true
+        });
+        CodeMirror.on(myWidget, "mousedown", function () {
+            myRange.clear();
+        });
+        myRange.on("clear", function (from, to) {
+            delete cm._lineFolds[from.line];
+            CodeMirror.signal(cm, "unfold", cm, from, to);
+        });
+
+        if (force === "fold") {
+            delete range.cleared;
+            cm._lineFolds[pos.line] = range;
+        } else {
+            delete cm._lineFolds[pos.line];
+        }
+        CodeMirror.signal(cm, force, cm, range.from, range.to);
+        return range;
+    }
+
+    /**
+        Initialises extensions and helpers on the CodeMirror object
+    */
+    function init() {
+        CodeMirror.defineExtension("foldCode", function (pos, options, force) {
+            return doFold(this, pos, options, force);
+        });
+
+        CodeMirror.defineExtension("unfoldCode", function (pos, options) {
+            return doFold(this, pos, options, "unfold");
+        });
+
+        CodeMirror.registerHelper("fold", "combine", function () {
+            var funcs = Array.prototype.slice.call(arguments, 0);
+            return function (cm, start) {
+                var i;
+                for (i = 0; i < funcs.length; ++i) {
+                    var found = funcs[i] && funcs[i](cm, start);
+                    if (found) {
+                        return found;
+                    }
+                }
+            };
+        });
+
+        CodeMirror.defineExtension("isFolded", function (line) {
+            return this._lineFolds[line];
+        });
+        /**
+          Checks the validity of the ranges passed in the parameter and returns the foldranges
+          that are still valid in the current document
+          @param {object} folds the dictionary of lines in the current document that should be folded
+          @returns {object} valid folds found in those passed in parameter
+        */
+        CodeMirror.defineExtension("getValidFolds", function (folds) {
+            var keys, rf = CodeMirror.fold.auto, cm = this, result = {};
+            if (folds && (keys = Object.keys(folds)).length) {
+                var range, cachedRange;
+                keys.forEach(function (lineNumber) {
+                    lineNumber = +lineNumber;
+                    if (lineNumber >= cm.firstLine() && lineNumber <= cm.lastLine()) {
+                        range = rf(cm, CodeMirror.Pos(lineNumber));
+                        cachedRange = folds[lineNumber];
+                        if (range && cachedRange && range.from.line === cachedRange.from.line &&
+                                range.to.line === cachedRange.to.line) {
+                            cm.foldCode(lineNumber, {range: folds[lineNumber]}, "fold");
+                            result[lineNumber] = folds[lineNumber];
+                        }
+                    }
+                });
+            }
+            return result;
+        });
+
+        CodeMirror.commands.toggleFold = function (cm) {
+            cm.foldCode(cm.getCursor());
+        };
+        CodeMirror.commands.fold = function (cm, options, force) {
+            cm.foldCode(cm.getCursor(), options, "fold");
+        };
+        CodeMirror.commands.unfold = function (cm, options, force) {
+            cm.foldCode(cm.getCursor(), options, "unfold");
+        };
+
+        CodeMirror.commands.foldAll = function (cm) {
+            cm.operation(function () {
+                var i, e;
+                for (i = cm.firstLine(), e = cm.lastLine(); i <= e; i++) {
+                    cm.foldCode(CodeMirror.Pos(i, 0), null, "fold");
+                }
+            });
+        };
+
+        CodeMirror.commands.unfoldAll = function (cm, from, to) {
+            from = from || cm.firstLine();
+            to = to || cm.lastLine();
+            cm.operation(function () {
+                var i, e;
+                for (i = from, e = to; i <= e; i++) {
+                    if (cm.isFolded(i)) { cm.unfoldCode(i, {range: cm._lineFolds[i]}); }
+                }
+            });
+        };
+        /**
+            Folds the specified range. The descendants of any fold regions within the range are also folded up to
+            a level set globally in the codeFolding preferences
+        */
+        CodeMirror.commands.foldToLevel = function (cm, start, end) {
+            var rf = CodeMirror.fold.auto, level = prefs.getSetting("maxFoldLevel");
+            function foldLevel(n, from, to) {
+                if (n > 0) {
+                    var i = from, range;
+                    while (i < to) {
+                        range = rf(cm, CodeMirror.Pos(i, 0));
+                        if (range) {
+                            //call fold level for the range just folded
+                            foldLevel(n - 1, range.from.line + 1, range.to.line - 1);
+                            cm.foldCode(CodeMirror.Pos(i, 0), null, "fold");
+                            i = range.to.line + 1;
+                        } else {
+                            i++;
+                        }
+                    }
+                }
+            }
+            cm.operation(function () {
+                start = start === undefined ? cm.firstLine() : start;
+                end = end || cm.lastLine();
+                foldLevel(level, start, end);
+            });
+        };
+
+        CodeMirror.registerHelper("fold", "auto", function (cm, start) {
+            var helpers = cm.getHelpers(start, "fold"), i, cur;
+            //ensure mode helper is loaded if there is one
+            var mode = cm.getMode().name;
+            var modeHelper = CodeMirror.fold[mode];
+            if (modeHelper && helpers.indexOf(modeHelper) < 0) {
+                helpers.push(modeHelper);
+            }
+            for (i = 0; i < helpers.length; i++) {
+                cur = helpers[i](cm, start);
+                if (cur) { return cur; }
+            }
+        });
+    }
+
+    exports.init = init;
+});