From 0fa3c5b37363545a1888c6085af2ed11550f84d4 Mon Sep 17 00:00:00 2001 From: campbelle2 Date: Mon, 1 Aug 2022 14:58:50 -0400 Subject: [PATCH 1/3] added code to allow for code completion in Java --- runestone/activecode/js/activecode.js | 21 ++++++++++++++++++--- runestone/lp/js/lp.js | 1 + 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/runestone/activecode/js/activecode.js b/runestone/activecode/js/activecode.js index 395bd7941..17897e1ad 100755 --- a/runestone/activecode/js/activecode.js +++ b/runestone/activecode/js/activecode.js @@ -19,6 +19,7 @@ import "codemirror/mode/htmlmixed/htmlmixed.js"; import "codemirror/mode/xml/xml.js"; import "codemirror/mode/javascript/javascript.js"; import "codemirror/mode/sql/sql.js"; +import "codemirror/mode/java/java.js"; import "codemirror/mode/clike/clike.js"; import "codemirror/mode/octave/octave.js"; import "./../css/activecode.css"; @@ -48,9 +49,23 @@ window.edList = {}; var socket, connection, doc; var chatcodesServer = "chat.codes"; -CodeMirror.commands.autocomplete = function (cm) { - cm.showHint({ hint: CodeMirror.hint.anyword }); -}; +CodeMirror.commands.autocomplete = function(cm) { + var doc = cm.getDoc(); + var POS = doc.getCursor(); + var mode = CodeMirror.innerMode(cm.getMode(), cm.getTokenAt(POS).state).mode.name; + console.log(mode) + if (mode == 'xml') { //html depends on xml + CodeMirror.showHint(cm, CodeMirror.hint.html); + } else if (mode == 'javascript') { + CodeMirror.showHint(cm, CodeMirror.hint.javascript); + } else if (mode == 'css') { + CodeMirror.showHint(cm, CodeMirror.hint.css); + } else if (mode == 'python') { + CodeMirror.showHint(cm, CodeMirror.hint.python); + // } else if (mode == 'cplusplus') { + // CodeMirror.showHint(cm, CodeMirror.hint.cplusplus); + } + }; // separate into constructor and init export class ActiveCode extends RunestoneBase { diff --git a/runestone/lp/js/lp.js b/runestone/lp/js/lp.js index 15f22ec92..3fc435a96 100644 --- a/runestone/lp/js/lp.js +++ b/runestone/lp/js/lp.js @@ -28,6 +28,7 @@ import CodeMirror from "codemirror"; import "codemirror/mode/gas/gas.js"; import "codemirror/mode/python/python.js"; import "codemirror/mode/javascript/javascript.js"; +import "codemirror/mode/java/java.js"; import "codemirror/mode/sql/sql.js"; import "codemirror/mode/clike/clike.js"; import "codemirror/mode/octave/octave.js"; From 2f78d0060fee4262e5d40b8302d35b04400a11fb Mon Sep 17 00:00:00 2001 From: campbelle2 Date: Tue, 2 Aug 2022 09:57:21 -0400 Subject: [PATCH 2/3] added code necessary for autocomplete --- runestone/activecode/js/activecode.js | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/runestone/activecode/js/activecode.js b/runestone/activecode/js/activecode.js index 17897e1ad..a344ec259 100755 --- a/runestone/activecode/js/activecode.js +++ b/runestone/activecode/js/activecode.js @@ -53,7 +53,7 @@ CodeMirror.commands.autocomplete = function(cm) { var doc = cm.getDoc(); var POS = doc.getCursor(); var mode = CodeMirror.innerMode(cm.getMode(), cm.getTokenAt(POS).state).mode.name; - console.log(mode) + console.log(mode) if (mode == 'xml') { //html depends on xml CodeMirror.showHint(cm, CodeMirror.hint.html); } else if (mode == 'javascript') { @@ -64,7 +64,10 @@ CodeMirror.commands.autocomplete = function(cm) { CodeMirror.showHint(cm, CodeMirror.hint.python); // } else if (mode == 'cplusplus') { // CodeMirror.showHint(cm, CodeMirror.hint.cplusplus); - } + } else { + CodeMirror.showHint(cm, CodeMirror.hint.cplusplus); + //cm.showHint({ hint: CodeMirror.hint.anyword }); + } }; // separate into constructor and init From fbed0aa1a0c1141e8a957b707294efa34201ecd2 Mon Sep 17 00:00:00 2001 From: campbelle2 Date: Wed, 3 Aug 2022 15:56:04 -0400 Subject: [PATCH 3/3] moved java.js file to activecode --- runestone/activecode/java/java.js | 373 ++++++++++++++++++++++++++++++ 1 file changed, 373 insertions(+) create mode 100644 runestone/activecode/java/java.js diff --git a/runestone/activecode/java/java.js b/runestone/activecode/java/java.js new file mode 100644 index 000000000..6f03661f4 --- /dev/null +++ b/runestone/activecode/java/java.js @@ -0,0 +1,373 @@ +// CodeMirror, copyright (c) by Marijn Haverbeke and others +// Distributed under an MIT license: https://codemirror.net/LICENSE +(function(mod) { + if (typeof exports == "object" && typeof module == "object") // CommonJS + mod(require("codemirror")); + else if (typeof define == "function" && define.amd) // AMD + define(["../../lib/codemirror"], mod); + else // Plain browser env + mod(CodeMirror); +})(function(CodeMirror) { + "use strict"; + + function wordRegexp(words) { + return new RegExp("^((" + words.join(")|(") + "))\\b"); + } + + var wordOperators = wordRegexp(["and", "or", "not", "is"]); + var commonKeywords = ["abstract", "continue", "for", "new", "switch", "assert", + "default", "goto", "package", "synchronized", + "boolean", "do", "if", "private", "this", + "break", "double", "implements", "protected", "throw", + "byte", "else", "import", "public", "throws", + "case", "enum", "instanceof", "return", "transient", + "catch", "extends", "int", "short", "try", + "char", "final", "interface", "static", "void", + "class", "finally", "long", "strictfp", "volatile", + "const", "float", "native", "super", "while"]; + var commonBuiltins = []; + CodeMirror.registerHelper("hintWords", "java", commonKeywords.concat(commonBuiltins)); + +CodeMirror.defineMode("java", function(conf, parserConf) { + var ERRORCLASS = "error"; + + var delimiters = parserConf.delimiters || parserConf.singleDelimiters || /^[\(\)\[\]\{\}@,:`=;\.\\]/; + // (Backwards-compatibility with old, cumbersome config system) + var operators = [parserConf.singleOperators, parserConf.doubleOperators, parserConf.doubleDelimiters, parserConf.tripleDelimiters, + parserConf.operators || /^([-+*/%\/&|^]=?|[<>=]+|\/\/=?|\*\*=?|!=|[~!@]|\.\.\.)/] + for (var i = 0; i < operators.length; i++) if (!operators[i]) operators.splice(i--, 1) + + var hangingIndent = parserConf.hangingIndent || conf.indentUnit; + + var myKeywords = commonKeywords, myBuiltins = commonBuiltins; + if (parserConf.extra_keywords != undefined) + myKeywords = myKeywords.concat(parserConf.extra_keywords); + + if (parserConf.extra_builtins != undefined) + myBuiltins = myBuiltins.concat(parserConf.extra_builtins); + + + var keywords = wordRegexp(myKeywords); + var builtins = wordRegexp(myBuiltins); + + // tokenizers + function tokenBase(stream, state) { + var sol = stream.sol() && state.lastToken != "\\" + if (sol) state.indent = stream.indentation() + // Handle scope changes + if (sol && top(state).type == "java") { + var scopeOffset = top(state).offset; + if (stream.eatSpace()) { + var lineOffset = stream.indentation(); + if (lineOffset > scopeOffset) + pushJavaScope(state); + else if (lineOffset < scopeOffset && dedent(stream, state) && stream.peek() != "#") + state.errorToken = true; + return null; + } else { + var style = tokenBaseInner(stream, state); + if (scopeOffset > 0 && dedent(stream, state)) + style += " " + ERRORCLASS; + return style; + } + } + return tokenBaseInner(stream, state); + } + + function tokenBaseInner(stream, state, inFormat) { + if (stream.eatSpace()) return null; + + // Handle Comments + if (!inFormat && stream.match(/^#.*/)) return "comment"; + + // Handle Number Literals + if (stream.match(/^[0-9\.]/, false)) { + var floatLiteral = false; + // Floats + if (stream.match(/^[\d_]*\.\d+(e[\+\-]?\d+)?/i)) { floatLiteral = true; } + if (stream.match(/^[\d_]+\.\d*/)) { floatLiteral = true; } + if (stream.match(/^\.\d+/)) { floatLiteral = true; } + if (floatLiteral) { + // Float literals may be "imaginary" + stream.eat(/J/i); + return "number"; + } + // Integers + var intLiteral = false; + // Hex + if (stream.match(/^0x[0-9a-f_]+/i)) intLiteral = true; + // Binary + if (stream.match(/^0b[01_]+/i)) intLiteral = true; + // Octal + if (stream.match(/^0o[0-7_]+/i)) intLiteral = true; + // Decimal + if (stream.match(/^[1-9][\d_]*(e[\+\-]?[\d_]+)?/)) { + // Decimal literals may be "imaginary" + stream.eat(/J/i); + // TODO - Can you have imaginary longs? + intLiteral = true; + } + // Zero by itself with no other piece of number. + if (stream.match(/^0(?![\dx])/i)) intLiteral = true; + if (intLiteral) { + // Integer literals may be "long" + stream.eat(/L/i); + return "number"; + } + } + + // Handle Strings + if (stream.match(stringPrefixes)) { + var isFmtString = stream.current().toLowerCase().indexOf('f') !== -1; + if (!isFmtString) { + state.tokenize = tokenStringFactory(stream.current(), state.tokenize); + return state.tokenize(stream, state); + } else { + state.tokenize = formatStringFactory(stream.current(), state.tokenize); + return state.tokenize(stream, state); + } + } + + for (var i = 0; i < operators.length; i++) + if (stream.match(operators[i])) return "operator" + + if (stream.match(delimiters)) return "punctuation"; + + if (state.lastToken == "." && stream.match(identifiers)) + return "property"; + + if (stream.match(keywords) || stream.match(wordOperators)) + return "keyword"; + + if (stream.match(builtins)) + return "builtin"; + + if (stream.match(/^(self|cls)\b/)) + return "variable-2"; + + if (stream.match(identifiers)) { + if (state.lastToken == "def" || state.lastToken == "class") + return "def"; + return "variable"; + } + + // Handle non-detected items + stream.next(); + return inFormat ? null :ERRORCLASS; + } + + function formatStringFactory(delimiter, tokenOuter) { + while ("rubf".indexOf(delimiter.charAt(0).toLowerCase()) >= 0) + delimiter = delimiter.substr(1); + + var singleline = delimiter.length == 1; + var OUTCLASS = "string"; + + function tokenNestedExpr(depth) { + return function(stream, state) { + var inner = tokenBaseInner(stream, state, true) + if (inner == "punctuation") { + if (stream.current() == "{") { + state.tokenize = tokenNestedExpr(depth + 1) + } else if (stream.current() == "}") { + if (depth > 1) state.tokenize = tokenNestedExpr(depth - 1) + else state.tokenize = tokenString + } + } + return inner + } + } + + function tokenString(stream, state) { + while (!stream.eol()) { + stream.eatWhile(/[^'"\{\}\\]/); + if (stream.eat("\\")) { + stream.next(); + if (singleline && stream.eol()) + return OUTCLASS; + } else if (stream.match(delimiter)) { + state.tokenize = tokenOuter; + return OUTCLASS; + } else if (stream.match('{{')) { + // ignore {{ in f-str + return OUTCLASS; + } else if (stream.match('{', false)) { + // switch to nested mode + state.tokenize = tokenNestedExpr(0) + if (stream.current()) return OUTCLASS; + else return state.tokenize(stream, state) + } else if (stream.match('}}')) { + return OUTCLASS; + } else if (stream.match('}')) { + // single } in f-string is an error + return ERRORCLASS; + } else { + stream.eat(/['"]/); + } + } + if (singleline) { + if (parserConf.singleLineStringErrors) + return ERRORCLASS; + else + state.tokenize = tokenOuter; + } + return OUTCLASS; + } + tokenString.isString = true; + return tokenString; + } + + function tokenStringFactory(delimiter, tokenOuter) { + while ("rubf".indexOf(delimiter.charAt(0).toLowerCase()) >= 0) + delimiter = delimiter.substr(1); + + var singleline = delimiter.length == 1; + var OUTCLASS = "string"; + + function tokenString(stream, state) { + while (!stream.eol()) { + stream.eatWhile(/[^'"\\]/); + if (stream.eat("\\")) { + stream.next(); + if (singleline && stream.eol()) + return OUTCLASS; + } else if (stream.match(delimiter)) { + state.tokenize = tokenOuter; + return OUTCLASS; + } else { + stream.eat(/['"]/); + } + } + if (singleline) { + if (parserConf.singleLineStringErrors) + return ERRORCLASS; + else + state.tokenize = tokenOuter; + } + return OUTCLASS; + } + tokenString.isString = true; + return tokenString; + } + + function pushJavaScope(state) { + while (top(state).type != "java") state.scopes.pop() + state.scopes.push({offset: top(state).offset + conf.indentUnit, + type: "java", + align: null}) + } + + function pushBracketScope(stream, state, type) { + var align = stream.match(/^[\s\[\{\(]*(?:#|$)/, false) ? null : stream.column() + 1 + state.scopes.push({offset: state.indent + hangingIndent, + type: type, + align: align}) + } + + function dedent(stream, state) { + var indented = stream.indentation(); + while (state.scopes.length > 1 && top(state).offset > indented) { + if (top(state).type != "java") return true; + state.scopes.pop(); + } + return top(state).offset != indented; + } + + function tokenLexer(stream, state) { + if (stream.sol()) { + state.beginningOfLine = true; + state.dedent = false; + } + + var style = state.tokenize(stream, state); + var current = stream.current(); + + // Handle decorators + + if (/\S/.test(current)) state.beginningOfLine = false; + + if ((style == "variable" || style == "builtin") + && state.lastToken == "meta") + style = "meta"; + + // Handle scope changes. + if (current == "pass" || current == "return") + state.dedent = true; + + if (current == "lambda") state.lambda = true; + if (current == ":" && !state.lambda && top(state).type == "java" && stream.match(/^\s*(?:#|$)/, false)) + pushJavaScope(state); + + if (current.length == 1 && !/string|comment/.test(style)) { + var delimiter_index = "[({".indexOf(current); + if (delimiter_index != -1) + pushBracketScope(stream, state, "])}".slice(delimiter_index, delimiter_index+1)); + + delimiter_index = "])}".indexOf(current); + if (delimiter_index != -1) { + if (top(state).type == current) state.indent = state.scopes.pop().offset - hangingIndent + else return ERRORCLASS; + } + } + if (state.dedent && stream.eol() && top(state).type == "java" && state.scopes.length > 1) + state.scopes.pop(); + + return style; + } + + var external = { + startState: function(basecolumn) { + return { + tokenize: tokenBase, + scopes: [{offset: basecolumn || 0, type: "java", align: null}], + indent: basecolumn || 0, + lastToken: null, + lambda: false, + dedent: 0 + }; + }, + + token: function(stream, state) { + var addErr = state.errorToken; + if (addErr) state.errorToken = false; + var style = tokenLexer(stream, state); + + if (style && style != "comment") + state.lastToken = (style == "keyword" || style == "punctuation") ? stream.current() : style; + if (style == "punctuation") style = null; + + if (stream.eol() && state.lambda) + state.lambda = false; + return addErr ? style + " " + ERRORCLASS : style; + }, + + indent: function(state, textAfter) { + if (state.tokenize != tokenBase) + return state.tokenize.isString ? CodeMirror.Pass : 0; + + var scope = top(state) + var closing = scope.type == textAfter.charAt(0) || + scope.type == "java" && !state.dedent && /^(else:|elif |except |finally:)/.test(textAfter) + if (scope.align != null) + return scope.align - (closing ? 1 : 0) + else + return scope.offset - (closing ? hangingIndent : 0) + }, + + electricInput: /^\s*([\}\]\)]|else:|elif |except |finally:)$/, + closeBrackets: {triples: "'\""}, + lineComment: "#", + fold: "indent" + }; + return external; + }); + + CodeMirror.defineMIME("text/x-java", "java"); + CodeMirror.defineMIME("text/java", "java"); + + var words = function(str) { return str.split(" "); }; + + CodeMirror.defineMIME("text/x-cava", { + name: "java" + }); +}); \ No newline at end of file