1 files changed, 196 insertions, 0 deletions
diff --git a/public/admin/view/javascript/codemirror/lib/formatting.js b/public/admin/view/javascript/codemirror/lib/formatting.js
new file mode 100644
index 0000000..00ffe78
--- /dev/null
+++ b/public/admin/view/javascript/codemirror/lib/formatting.js
@@ -0,0 +1,196 @@
+// ============== Formatting extensions ============================
+(function() {
+  // Define extensions for a few modes
+  CodeMirror.extendMode("css", {
+    commentStart: "/*",
+    commentEnd: "*/",
+    wordWrapChars: [";", "\\{", "\\}"],
+    autoFormatLineBreaks: function (text) {
+      return text.replace(new RegExp("(;|\\{|\\})([^\r\n])", "g"), "$1\n$2");
+    }
+  });
+
+  function jsNonBreakableBlocks(text) {
+    var nonBreakableRegexes = [/for\s*?\((.*?)\)/,
+                               /\"(.*?)(\"|$)/,
+                               /\'(.*?)(\'|$)/,
+                               /\/\*(.*?)(\*\/|$)/,
+                               /\/\/.*/];
+    var nonBreakableBlocks = [];
+    for (var i = 0; i < nonBreakableRegexes.length; i++) {
+      var curPos = 0;
+      while (curPos < text.length) {
+        var m = text.substr(curPos).match(nonBreakableRegexes[i]);
+        if (m != null) {
+          nonBreakableBlocks.push({
+            start: curPos + m.index,
+            end: curPos + m.index + m[0].length
+          });
+          curPos += m.index + Math.max(1, m[0].length);
+        }
+        else { // No more matches
+          break;
+        }
+      }
+    }
+    nonBreakableBlocks.sort(function (a, b) {
+      return a.start - b.start;
+    });
+
+    return nonBreakableBlocks;
+  }
+
+  CodeMirror.extendMode("javascript", {
+    commentStart: "/*",
+    commentEnd: "*/",
+    wordWrapChars: [";", "\\{", "\\}"],
+
+    autoFormatLineBreaks: function (text) {
+      var curPos = 0;
+      var split = this.jsonMode ? function(str) {
+        return str.replace(/([,{])/g, "$1\n").replace(/}/g, "\n}");
+      } : function(str) {
+        return str.replace(/(;|\{|\})([^\r\n;])/g, "$1\n$2");
+      };
+      var nonBreakableBlocks = jsNonBreakableBlocks(text), res = "";
+      if (nonBreakableBlocks != null) {
+        for (var i = 0; i < nonBreakableBlocks.length; i++) {
+          if (nonBreakableBlocks[i].start > curPos) { // Break lines till the block
+            res += split(text.substring(curPos, nonBreakableBlocks[i].start));
+            curPos = nonBreakableBlocks[i].start;
+          }
+          if (nonBreakableBlocks[i].start <= curPos
+              && nonBreakableBlocks[i].end >= curPos) { // Skip non-breakable block
+            res += text.substring(curPos, nonBreakableBlocks[i].end);
+            curPos = nonBreakableBlocks[i].end;
+          }
+        }
+        if (curPos < text.length)
+          res += split(text.substr(curPos));
+      } else {
+        res = split(text);
+      }
+      return res.replace(/^\n*|\n*$/, "");
+    }
+  });
+
+  CodeMirror.extendMode("xml", {
+    commentStart: "<!--",
+    commentEnd: "-->",
+    wordWrapChars: [">"],
+
+    autoFormatLineBreaks: function (text) {
+      var lines = text.split("\n");
+      var reProcessedPortion = new RegExp("(^\\s*?<|^[^<]*?)(.+)(>\\s*?$|[^>]*?$)");
+      var reOpenBrackets = new RegExp("<", "g");
+      var reCloseBrackets = new RegExp("(>)([^\r\n])", "g");
+      for (var i = 0; i < lines.length; i++) {
+        var mToProcess = lines[i].match(reProcessedPortion);
+        if (mToProcess != null && mToProcess.length > 3) { // The line starts with whitespaces and ends with whitespaces
+          lines[i] = mToProcess[1]
+            + mToProcess[2].replace(reOpenBrackets, "\n$&").replace(reCloseBrackets, "$1\n$2")
+            + mToProcess[3];
+          continue;
+        }
+      }
+      return lines.join("\n");
+    }
+  });
+
+  function localModeAt(cm, pos) {
+    return CodeMirror.innerMode(cm.getMode(), cm.getTokenAt(pos).state).mode;
+  }
+
+  function enumerateModesBetween(cm, line, start, end) {
+    var outer = cm.getMode(), text = cm.getLine(line);
+    if (end == null) end = text.length;
+    if (!outer.innerMode) return [{from: start, to: end, mode: outer}];
+    var state = cm.getTokenAt({line: line, ch: start}).state;
+    var mode = CodeMirror.innerMode(outer, state).mode;
+    var found = [], stream = new CodeMirror.StringStream(text);
+    stream.pos = stream.start = start;
+    for (;;) {
+      outer.token(stream, state);
+      var curMode = CodeMirror.innerMode(outer, state).mode;
+      if (curMode != mode) {
+        var cut = stream.start;
+        // Crappy heuristic to deal with the fact that a change in
+        // mode can occur both at the end and the start of a token,
+        // and we don't know which it was.
+        if (mode.name == "xml" && text.charAt(stream.pos - 1) == ">") cut = stream.pos;
+        found.push({from: start, to: cut, mode: mode});
+        start = cut;
+        mode = curMode;
+      }
+      if (stream.pos >= end) break;
+      stream.start = stream.pos;
+    }
+    if (start < end) found.push({from: start, to: end, mode: mode});
+    return found;
+  }
+
+  // Comment/uncomment the specified range
+  CodeMirror.defineExtension("commentRange", function (isComment, from, to) {
+    var curMode = localModeAt(this, from), cm = this;
+    this.operation(function() {
+      if (isComment) { // Comment range
+        cm.replaceRange(curMode.commentEnd, to);
+        cm.replaceRange(curMode.commentStart, from);
+        if (from.line == to.line && from.ch == to.ch) // An empty comment inserted - put cursor inside
+          cm.setCursor(from.line, from.ch + curMode.commentStart.length);
+      } else { // Uncomment range
+        var selText = cm.getRange(from, to);
+        var startIndex = selText.indexOf(curMode.commentStart);
+        var endIndex = selText.lastIndexOf(curMode.commentEnd);
+        if (startIndex > -1 && endIndex > -1 && endIndex > startIndex) {
+          // Take string till comment start
+          selText = selText.substr(0, startIndex)
+          // From comment start till comment end
+            + selText.substring(startIndex + curMode.commentStart.length, endIndex)
+          // From comment end till string end
+            + selText.substr(endIndex + curMode.commentEnd.length);
+        }
+        cm.replaceRange(selText, from, to);
+      }
+    });
+  });
+
+  // Applies automatic mode-aware indentation to the specified range
+  CodeMirror.defineExtension("autoIndentRange", function (from, to) {
+    var cmInstance = this;
+    this.operation(function () {
+      for (var i = from.line; i <= to.line; i++) {
+        cmInstance.indentLine(i, "smart");
+      }
+    });
+  });
+
+  // Applies automatic formatting to the specified range
+  CodeMirror.defineExtension("autoFormatRange", function (from, to) {
+    var cm = this;
+    cm.operation(function () {
+      for (var cur = from.line, end = to.line; cur <= end; ++cur) {
+        var f = {line: cur, ch: cur == from.line ? from.ch : 0};
+        var t = {line: cur, ch: cur == end ? to.ch : null};
+        var modes = enumerateModesBetween(cm, cur, f.ch, t.ch), mangled = "";
+        var text = cm.getRange(f, t);
+        for (var i = 0; i < modes.length; ++i) {
+          var part = modes.length > 1 ? text.slice(modes[i].from, modes[i].to) : text;
+          if (mangled) mangled += "\n";
+          if (modes[i].mode.autoFormatLineBreaks) {
+            mangled += modes[i].mode.autoFormatLineBreaks(part);
+          } else mangled += text;
+        }
+        if (mangled != text) {
+          for (var count = 0, pos = mangled.indexOf("\n"); pos != -1; pos = mangled.indexOf("\n", pos + 1), ++count) {}
+          cm.replaceRange(mangled, f, t);
+          cur += count;
+          end += count;
+        }
+      }
+      for (var cur = from.line + 1; cur <= end; ++cur)
+        cm.indentLine(cur, "smart");
+      cm.setSelection(from, cm.getCursor(false));
+    });
+  });
+})();