Go mode added

Makefile.dryice.js

@@ -220,7 +220,7 @@ function buildAce(aceProject, options) {
             "css", "html", "javascript", "php", "coldfusion", "python", "lua", "xml", "ruby", "java", "c_cpp",
             "coffee", "perl", "csharp", "haxe", "liquid", "svg", "clojure", "scss", "json", "groovy",
             "ocaml", "scala", "textile", "scad", "markdown", "latex", "powershell", "sql",
-            "text", "pgsql", "sh", "xquery", "less"
+            "text", "pgsql", "sh", "xquery", "less", "golang"
         ],
         themes: [
             "chrome", "clouds", "clouds_midnight", "cobalt", "crimson_editor", "dawn",

lib/ace/mode/golang.js

@@ -0,0 +1,78 @@
+define(function(require, exports, module) {
+
+    var oop = require("ace/lib/oop");
+    var TextMode = require("ace/mode/text").Mode;
+    var Tokenizer = require("ace/tokenizer").Tokenizer;
+    var GolangHighlightRules = require("ace/mode/golang_highlight_rules").GolangHighlightRules;
+    var MatchingBraceOutdent = require("ace/mode/matching_brace_outdent").MatchingBraceOutdent;
+    
+    var Mode = function() {
+        this.$tokenizer = new Tokenizer(new GolangHighlightRules().getRules());
+        this.$outdent = new MatchingBraceOutdent();
+    };
+    oop.inherits(Mode, TextMode);
+    
+    (function() {
+        
+        this.toggleCommentLines = function(state, doc, startRow, endRow) {
+            var outdent = true;
+            var outentedRows = [];
+            var re = /^(\s*)\/\//;
+
+            for (var i=startRow; i<= endRow; i++) {
+                if (!re.test(doc.getLine(i))) {
+                    outdent = false;
+                    break;
+                }
+            }
+
+            if (outdent) {
+                var deleteRange = new Range(0, 0, 0, 0);
+                for (var i=startRow; i<= endRow; i++)
+                {
+                    var line = doc.getLine(i);
+                    var m = line.match(re);
+                    deleteRange.start.row = i;
+                    deleteRange.end.row = i;
+                    deleteRange.end.column = m[0].length;
+                    doc.replace(deleteRange, m[1]);
+                }
+            }
+            else {
+                doc.indentRows(startRow, endRow, "//");
+            }
+        };
+
+        this.getNextLineIndent = function(state, line, tab) {
+            var indent = this.$getIndent(line);
+
+            var tokenizedLine = this.$tokenizer.getLineTokens(line, state);
+            var tokens = tokenizedLine.tokens;
+            var endState = tokenizedLine.state;
+
+            if (tokens.length && tokens[tokens.length-1].type == "comment") {
+                return indent;
+            }
+            
+            if (state == "start") {
+                var match = line.match(/^.*[\{\(\[]\s*$/);
+                if (match) {
+                    indent += tab;
+                }
+            }
+
+            return indent;
+        };//end getNextLineIndent
+
+        this.checkOutdent = function(state, line, input) {
+            return this.$outdent.checkOutdent(line, input);
+        };
+
+        this.autoOutdent = function(state, doc, row) {
+            this.$outdent.autoOutdent(doc, row);
+        };
+
+    }).call(Mode.prototype);
+
+    exports.Mode = Mode;
+});

lib/ace/mode/golang_highlight_rules.js

@@ -0,0 +1,126 @@
+define(function(require, exports, module) {
+    var oop = require("ace/lib/oop");
+    var lang = require("ace/lib/lang");
+    var DocCommentHighlightRules = require("ace/mode/doc_comment_highlight_rules").DocCommentHighlightRules;
+    var TextHighlightRules = require("ace/mode/text_highlight_rules").TextHighlightRules;
+
+    var GolangHighlightRules = function() {
+        var keywords = lang.arrayToMap(
+            ("true|else|false|break|case|return|goto|if|const|" +
+             "continue|struct|default|switch|for|" +
+             "func|import|package|chan|defer|fallthrough|go|interface|map|range" +
+             "select|type|var").split("|")
+        );
+
+        var buildinConstants = lang.arrayToMap(
+            ("nit|true|false|iota").split("|")
+        );
+
+        this.$rules = {
+            "start" : [
+                {
+                    token : "comment",
+                    regex : "\\/\\/.*$"
+                },
+                new DocCommentHighlightRules().getStartRule("doc-start"),
+                {
+                    token : "comment", // multi line comment
+                    merge : true,
+                    regex : "\\/\\*",
+                    next : "comment"
+                }, {
+                    token : "string", // single line
+                    regex : '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
+                }, {
+                    token : "string", // multi line string start
+                    merge : true,
+                    regex : '["].*\\\\$',
+                    next : "qqstring"
+                }, {
+                    token : "string", // single line
+                    regex : "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"
+                }, {
+                    token : "string", // multi line string start
+                    merge : true,
+                    regex : "['].*\\\\$",
+                    next : "qstring"
+                }, {
+                    token : "constant.numeric", // hex
+                    regex : "0[xX][0-9a-fA-F]+\\b"
+                }, {
+                    token : "constant.numeric", // float
+                    regex : "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b"
+                }, {
+                    token : "constant", // <CONSTANT>
+                    regex : "<[a-zA-Z0-9.]+>"
+                }, {
+                    token : "keyword", // pre-compiler directivs
+                    regex : "(?:#include|#pragma|#line|#define|#undef|#ifdef|#else|#elif|#endif|#ifndef)"
+                }, {
+                    token : function(value) {
+                        if (value == "this")
+                            return "variable.language";
+                        else if (keywords.hasOwnProperty(value))
+                            return "keyword";
+                        else if (buildinConstants.hasOwnProperty(value))
+                            return "constant.language";
+                        else
+                            return "identifier";
+                    },
+                    regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
+                }, {
+                    token : "keyword.operator",
+                    regex : "!|\\$|%|&|\\*|\\-\\-|\\-|\\+\\+|\\+|~|==|=|!=|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\\|\\||\\?\\:|\\*=|%=|\\+=|\\-=|&=|\\^=|\\b(?:in|new|delete|typeof|void)"
+                }, {
+                    token : "punctuation.operator",
+                    regex : "\\?|\\:|\\,|\\;|\\."
+                }, {
+                    token : "paren.lparen",
+                    regex : "[[({]"
+                }, {
+                    token : "paren.rparen",
+                    regex : "[\\])}]"
+                }, {
+                    token : "text",
+                    regex : "\\s+"
+                }
+            ],
+            "comment" : [
+                {
+                    token : "comment", // closing comment
+                    regex : ".*?\\*\\/",
+                    next : "start"
+                }, {
+                    token : "comment", // comment spanning whole line
+                    merge : true,
+                    regex : ".+"
+                }
+            ],
+            "qqstring" : [
+                {
+                    token : "string",
+                    regex : '(?:(?:\\\\.)|(?:[^"\\\\]))*?"',
+                    next : "start"
+                }, {
+                    token : "string",
+                    merge : true,
+                    regex : '.+'
+                }
+            ],
+            "qstring" : [
+                {
+                    token : "string",
+                    regex : "(?:(?:\\\\.)|(?:[^'\\\\]))*?'",
+                    next : "start"
+                }, {
+                    token : "string",
+                    merge : true,
+                    regex : '.+'
+                }
+            ]
+        };
+    }
+    oop.inherits(GolangHighlightRules, TextHighlightRules);
+
+    exports.GolangHighlightRules = GolangHighlightRules;
+});