forked from NYANDEV/forgejo
* Cleaning up public/ and documenting js/css libs. This commit mostly addresses #1484 by moving vendor'ed plugins into a vendor/ directory and documenting their upstream source and license in vendor/librejs.html. This also proves gitea is using only open source js/css libraries which helps toward reaching #1524. * Removing unused css file. The version of this file in use is located at: vendor/plugins/highlight/github.css * Cleaned up librejs.html and added javascript header A SafeJS function was added to templates/helper.go to allow keeping comments inside of javascript. A javascript comment was added in the header of templates/base/head.tmpl to mark all non-inline source as free. The librejs.html file was updated to meet the current librejs spec. I have now verified that the librejs plugin detects most of the scripts included in gitea and suspect the non-free detections are the result of a bug in the plugin. I believe this commit is enough to meet the C0.0 requirement of #1534. * Updating SafeJS function per lint suggestion * Added VERSIONS file, per request
This commit is contained in:
parent
64b7068846
commit
a915a09e4f
1339 changed files with 813 additions and 126 deletions
210
public/vendor/plugins/codemirror/mode/xquery/index.html
vendored
Normal file
210
public/vendor/plugins/codemirror/mode/xquery/index.html
vendored
Normal file
|
@ -0,0 +1,210 @@
|
|||
<!doctype html>
|
||||
|
||||
<title>CodeMirror: XQuery mode</title>
|
||||
<meta charset="utf-8"/>
|
||||
<link rel=stylesheet href="../../doc/docs.css">
|
||||
|
||||
<link rel="stylesheet" href="../../lib/codemirror.css">
|
||||
<link rel="stylesheet" href="../../theme/xq-dark.css">
|
||||
<script src="../../lib/codemirror.js"></script>
|
||||
<script src="xquery.js"></script>
|
||||
<style type="text/css">
|
||||
.CodeMirror {
|
||||
border-top: 1px solid black; border-bottom: 1px solid black;
|
||||
height:400px;
|
||||
}
|
||||
</style>
|
||||
<div id=nav>
|
||||
<a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
|
||||
|
||||
<ul>
|
||||
<li><a href="../../index.html">Home</a>
|
||||
<li><a href="../../doc/manual.html">Manual</a>
|
||||
<li><a href="https://github.com/codemirror/codemirror">Code</a>
|
||||
</ul>
|
||||
<ul>
|
||||
<li><a href="../index.html">Language modes</a>
|
||||
<li><a class=active href="#">XQuery</a>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<article>
|
||||
<h2>XQuery mode</h2>
|
||||
|
||||
|
||||
<div class="cm-s-default">
|
||||
<textarea id="code" name="code">
|
||||
xquery version "1.0-ml";
|
||||
(: this is
|
||||
: a
|
||||
"comment" :)
|
||||
let $let := <x attr="value">"test"<func>function() $var {function()} {$var}</func></x>
|
||||
let $joe:=1
|
||||
return element element {
|
||||
attribute attribute { 1 },
|
||||
element test { 'a' },
|
||||
attribute foo { "bar" },
|
||||
fn:doc()[ foo/@bar eq $let ],
|
||||
//x }
|
||||
|
||||
(: a more 'evil' test :)
|
||||
(: Modified Blakeley example (: with nested comment :) ... :)
|
||||
declare private function local:declare() {()};
|
||||
declare private function local:private() {()};
|
||||
declare private function local:function() {()};
|
||||
declare private function local:local() {()};
|
||||
let $let := <let>let $let := "let"</let>
|
||||
return element element {
|
||||
attribute attribute { try { xdmp:version() } catch($e) { xdmp:log($e) } },
|
||||
attribute fn:doc { "bar" castable as xs:string },
|
||||
element text { text { "text" } },
|
||||
fn:doc()[ child::eq/(@bar | attribute::attribute) eq $let ],
|
||||
//fn:doc
|
||||
}
|
||||
|
||||
|
||||
|
||||
xquery version "1.0-ml";
|
||||
|
||||
(: Copyright 2006-2010 Mark Logic Corporation. :)
|
||||
|
||||
(:
|
||||
: Licensed under the Apache License, Version 2.0 (the "License");
|
||||
: you may not use this file except in compliance with the License.
|
||||
: You may obtain a copy of the License at
|
||||
:
|
||||
: http://www.apache.org/licenses/LICENSE-2.0
|
||||
:
|
||||
: Unless required by applicable law or agreed to in writing, software
|
||||
: distributed under the License is distributed on an "AS IS" BASIS,
|
||||
: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
: See the License for the specific language governing permissions and
|
||||
: limitations under the License.
|
||||
:)
|
||||
|
||||
module namespace json = "http://marklogic.com/json";
|
||||
declare default function namespace "http://www.w3.org/2005/xpath-functions";
|
||||
|
||||
(: Need to backslash escape any double quotes, backslashes, and newlines :)
|
||||
declare function json:escape($s as xs:string) as xs:string {
|
||||
let $s := replace($s, "\\", "\\\\")
|
||||
let $s := replace($s, """", "\\""")
|
||||
let $s := replace($s, codepoints-to-string((13, 10)), "\\n")
|
||||
let $s := replace($s, codepoints-to-string(13), "\\n")
|
||||
let $s := replace($s, codepoints-to-string(10), "\\n")
|
||||
return $s
|
||||
};
|
||||
|
||||
declare function json:atomize($x as element()) as xs:string {
|
||||
if (count($x/node()) = 0) then 'null'
|
||||
else if ($x/@type = "number") then
|
||||
let $castable := $x castable as xs:float or
|
||||
$x castable as xs:double or
|
||||
$x castable as xs:decimal
|
||||
return
|
||||
if ($castable) then xs:string($x)
|
||||
else error(concat("Not a number: ", xdmp:describe($x)))
|
||||
else if ($x/@type = "boolean") then
|
||||
let $castable := $x castable as xs:boolean
|
||||
return
|
||||
if ($castable) then xs:string(xs:boolean($x))
|
||||
else error(concat("Not a boolean: ", xdmp:describe($x)))
|
||||
else concat('"', json:escape($x), '"')
|
||||
};
|
||||
|
||||
(: Print the thing that comes after the colon :)
|
||||
declare function json:print-value($x as element()) as xs:string {
|
||||
if (count($x/*) = 0) then
|
||||
json:atomize($x)
|
||||
else if ($x/@quote = "true") then
|
||||
concat('"', json:escape(xdmp:quote($x/node())), '"')
|
||||
else
|
||||
string-join(('{',
|
||||
string-join(for $i in $x/* return json:print-name-value($i), ","),
|
||||
'}'), "")
|
||||
};
|
||||
|
||||
(: Print the name and value both :)
|
||||
declare function json:print-name-value($x as element()) as xs:string? {
|
||||
let $name := name($x)
|
||||
let $first-in-array :=
|
||||
count($x/preceding-sibling::*[name(.) = $name]) = 0 and
|
||||
(count($x/following-sibling::*[name(.) = $name]) > 0 or $x/@array = "true")
|
||||
let $later-in-array := count($x/preceding-sibling::*[name(.) = $name]) > 0
|
||||
return
|
||||
|
||||
if ($later-in-array) then
|
||||
() (: I was handled previously :)
|
||||
else if ($first-in-array) then
|
||||
string-join(('"', json:escape($name), '":[',
|
||||
string-join((for $i in ($x, $x/following-sibling::*[name(.) = $name]) return json:print-value($i)), ","),
|
||||
']'), "")
|
||||
else
|
||||
string-join(('"', json:escape($name), '":', json:print-value($x)), "")
|
||||
};
|
||||
|
||||
(:~
|
||||
Transforms an XML element into a JSON string representation. See http://json.org.
|
||||
<p/>
|
||||
Sample usage:
|
||||
<pre>
|
||||
xquery version "1.0-ml";
|
||||
import module namespace json="http://marklogic.com/json" at "json.xqy";
|
||||
json:serialize(&lt;foo&gt;&lt;bar&gt;kid&lt;/bar&gt;&lt;/foo&gt;)
|
||||
</pre>
|
||||
Sample transformations:
|
||||
<pre>
|
||||
&lt;e/&gt; becomes {"e":null}
|
||||
&lt;e&gt;text&lt;/e&gt; becomes {"e":"text"}
|
||||
&lt;e&gt;quote " escaping&lt;/e&gt; becomes {"e":"quote \" escaping"}
|
||||
&lt;e&gt;backslash \ escaping&lt;/e&gt; becomes {"e":"backslash \\ escaping"}
|
||||
&lt;e&gt;&lt;a&gt;text1&lt;/a&gt;&lt;b&gt;text2&lt;/b&gt;&lt;/e&gt; becomes {"e":{"a":"text1","b":"text2"}}
|
||||
&lt;e&gt;&lt;a&gt;text1&lt;/a&gt;&lt;a&gt;text2&lt;/a&gt;&lt;/e&gt; becomes {"e":{"a":["text1","text2"]}}
|
||||
&lt;e&gt;&lt;a array="true"&gt;text1&lt;/a&gt;&lt;/e&gt; becomes {"e":{"a":["text1"]}}
|
||||
&lt;e&gt;&lt;a type="boolean"&gt;false&lt;/a&gt;&lt;/e&gt; becomes {"e":{"a":false}}
|
||||
&lt;e&gt;&lt;a type="number"&gt;123.5&lt;/a&gt;&lt;/e&gt; becomes {"e":{"a":123.5}}
|
||||
&lt;e quote="true"&gt;&lt;div attrib="value"/&gt;&lt;/e&gt; becomes {"e":"&lt;div attrib=\"value\"/&gt;"}
|
||||
</pre>
|
||||
<p/>
|
||||
Namespace URIs are ignored. Namespace prefixes are included in the JSON name.
|
||||
<p/>
|
||||
Attributes are ignored, except for the special attribute @array="true" that
|
||||
indicates the JSON serialization should write the node, even if single, as an
|
||||
array, and the attribute @type that can be set to "boolean" or "number" to
|
||||
dictate the value should be written as that type (unquoted). There's also
|
||||
an @quote attribute that when set to true writes the inner content as text
|
||||
rather than as structured JSON, useful for sending some XHTML over the
|
||||
wire.
|
||||
<p/>
|
||||
Text nodes within mixed content are ignored.
|
||||
|
||||
@param $x Element node to convert
|
||||
@return String holding JSON serialized representation of $x
|
||||
|
||||
@author Jason Hunter
|
||||
@version 1.0.1
|
||||
|
||||
Ported to xquery 1.0-ml; double escaped backslashes in json:escape
|
||||
:)
|
||||
declare function json:serialize($x as element()) as xs:string {
|
||||
string-join(('{', json:print-name-value($x), '}'), "")
|
||||
};
|
||||
</textarea>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
|
||||
lineNumbers: true,
|
||||
matchBrackets: true,
|
||||
theme: "xq-dark"
|
||||
});
|
||||
</script>
|
||||
|
||||
<p><strong>MIME types defined:</strong> <code>application/xquery</code>.</p>
|
||||
|
||||
<p>Development of the CodeMirror XQuery mode was sponsored by
|
||||
<a href="http://marklogic.com">MarkLogic</a> and developed by
|
||||
<a href="https://twitter.com/mbrevoort">Mike Brevoort</a>.
|
||||
</p>
|
||||
|
||||
</article>
|
67
public/vendor/plugins/codemirror/mode/xquery/test.js
vendored
Normal file
67
public/vendor/plugins/codemirror/mode/xquery/test.js
vendored
Normal file
|
@ -0,0 +1,67 @@
|
|||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
// Don't take these too seriously -- the expected results appear to be
|
||||
// based on the results of actual runs without any serious manual
|
||||
// verification. If a change you made causes them to fail, the test is
|
||||
// as likely to wrong as the code.
|
||||
|
||||
(function() {
|
||||
var mode = CodeMirror.getMode({tabSize: 4}, "xquery");
|
||||
function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); }
|
||||
|
||||
MT("eviltest",
|
||||
"[keyword xquery] [keyword version] [variable "1][keyword .][atom 0][keyword -][variable ml"][def&variable ;] [comment (: this is : a \"comment\" :)]",
|
||||
" [keyword let] [variable $let] [keyword :=] [variable <x] [variable attr][keyword =][variable "value">"test"<func>][def&variable ;function]() [variable $var] {[keyword function]()} {[variable $var]}[variable <][keyword /][variable func><][keyword /][variable x>]",
|
||||
" [keyword let] [variable $joe][keyword :=][atom 1]",
|
||||
" [keyword return] [keyword element] [variable element] {",
|
||||
" [keyword attribute] [variable attribute] { [atom 1] },",
|
||||
" [keyword element] [variable test] { [variable 'a'] }, [keyword attribute] [variable foo] { [variable "bar"] },",
|
||||
" [def&variable fn:doc]()[[ [variable foo][keyword /][variable @bar] [keyword eq] [variable $let] ]],",
|
||||
" [keyword //][variable x] } [comment (: a more 'evil' test :)]",
|
||||
" [comment (: Modified Blakeley example (: with nested comment :) ... :)]",
|
||||
" [keyword declare] [keyword private] [keyword function] [def&variable local:declare]() {()}[variable ;]",
|
||||
" [keyword declare] [keyword private] [keyword function] [def&variable local:private]() {()}[variable ;]",
|
||||
" [keyword declare] [keyword private] [keyword function] [def&variable local:function]() {()}[variable ;]",
|
||||
" [keyword declare] [keyword private] [keyword function] [def&variable local:local]() {()}[variable ;]",
|
||||
" [keyword let] [variable $let] [keyword :=] [variable <let>let] [variable $let] [keyword :=] [variable "let"<][keyword /let][variable >]",
|
||||
" [keyword return] [keyword element] [variable element] {",
|
||||
" [keyword attribute] [variable attribute] { [keyword try] { [def&variable xdmp:version]() } [keyword catch]([variable $e]) { [def&variable xdmp:log]([variable $e]) } },",
|
||||
" [keyword attribute] [variable fn:doc] { [variable "bar"] [variable castable] [keyword as] [atom xs:string] },",
|
||||
" [keyword element] [variable text] { [keyword text] { [variable "text"] } },",
|
||||
" [def&variable fn:doc]()[[ [qualifier child::][variable eq][keyword /]([variable @bar] [keyword |] [qualifier attribute::][variable attribute]) [keyword eq] [variable $let] ]],",
|
||||
" [keyword //][variable fn:doc]",
|
||||
" }");
|
||||
|
||||
MT("testEmptySequenceKeyword",
|
||||
"[string \"foo\"] [keyword instance] [keyword of] [keyword empty-sequence]()");
|
||||
|
||||
MT("testMultiAttr",
|
||||
"[tag <p ][attribute a1]=[string \"foo\"] [attribute a2]=[string \"bar\"][tag >][variable hello] [variable world][tag </p>]");
|
||||
|
||||
MT("test namespaced variable",
|
||||
"[keyword declare] [keyword namespace] [variable e] [keyword =] [string \"http://example.com/ANamespace\"][variable ;declare] [keyword variable] [variable $e:exampleComThisVarIsNotRecognized] [keyword as] [keyword element]([keyword *]) [variable external;]");
|
||||
|
||||
MT("test EQName variable",
|
||||
"[keyword declare] [keyword variable] [variable $\"http://www.example.com/ns/my\":var] [keyword :=] [atom 12][variable ;]",
|
||||
"[tag <out>]{[variable $\"http://www.example.com/ns/my\":var]}[tag </out>]");
|
||||
|
||||
MT("test EQName function",
|
||||
"[keyword declare] [keyword function] [def&variable \"http://www.example.com/ns/my\":fn] ([variable $a] [keyword as] [atom xs:integer]) [keyword as] [atom xs:integer] {",
|
||||
" [variable $a] [keyword +] [atom 2]",
|
||||
"}[variable ;]",
|
||||
"[tag <out>]{[def&variable \"http://www.example.com/ns/my\":fn]([atom 12])}[tag </out>]");
|
||||
|
||||
MT("test EQName function with single quotes",
|
||||
"[keyword declare] [keyword function] [def&variable 'http://www.example.com/ns/my':fn] ([variable $a] [keyword as] [atom xs:integer]) [keyword as] [atom xs:integer] {",
|
||||
" [variable $a] [keyword +] [atom 2]",
|
||||
"}[variable ;]",
|
||||
"[tag <out>]{[def&variable 'http://www.example.com/ns/my':fn]([atom 12])}[tag </out>]");
|
||||
|
||||
MT("testProcessingInstructions",
|
||||
"[def&variable data]([comment&meta <?target content?>]) [keyword instance] [keyword of] [atom xs:string]");
|
||||
|
||||
MT("testQuoteEscapeDouble",
|
||||
"[keyword let] [variable $rootfolder] [keyword :=] [string \"c:\\builds\\winnt\\HEAD\\qa\\scripts\\\"]",
|
||||
"[keyword let] [variable $keysfolder] [keyword :=] [def&variable concat]([variable $rootfolder], [string \"keys\\\"])");
|
||||
})();
|
437
public/vendor/plugins/codemirror/mode/xquery/xquery.js
vendored
Normal file
437
public/vendor/plugins/codemirror/mode/xquery/xquery.js
vendored
Normal file
|
@ -0,0 +1,437 @@
|
|||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: http://codemirror.net/LICENSE
|
||||
|
||||
(function(mod) {
|
||||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
||||
mod(require("../../lib/codemirror"));
|
||||
else if (typeof define == "function" && define.amd) // AMD
|
||||
define(["../../lib/codemirror"], mod);
|
||||
else // Plain browser env
|
||||
mod(CodeMirror);
|
||||
})(function(CodeMirror) {
|
||||
"use strict";
|
||||
|
||||
CodeMirror.defineMode("xquery", function() {
|
||||
|
||||
// The keywords object is set to the result of this self executing
|
||||
// function. Each keyword is a property of the keywords object whose
|
||||
// value is {type: atype, style: astyle}
|
||||
var keywords = function(){
|
||||
// convenience functions used to build keywords object
|
||||
function kw(type) {return {type: type, style: "keyword"};}
|
||||
var A = kw("keyword a")
|
||||
, B = kw("keyword b")
|
||||
, C = kw("keyword c")
|
||||
, operator = kw("operator")
|
||||
, atom = {type: "atom", style: "atom"}
|
||||
, punctuation = {type: "punctuation", style: null}
|
||||
, qualifier = {type: "axis_specifier", style: "qualifier"};
|
||||
|
||||
// kwObj is what is return from this function at the end
|
||||
var kwObj = {
|
||||
'if': A, 'switch': A, 'while': A, 'for': A,
|
||||
'else': B, 'then': B, 'try': B, 'finally': B, 'catch': B,
|
||||
'element': C, 'attribute': C, 'let': C, 'implements': C, 'import': C, 'module': C, 'namespace': C,
|
||||
'return': C, 'super': C, 'this': C, 'throws': C, 'where': C, 'private': C,
|
||||
',': punctuation,
|
||||
'null': atom, 'fn:false()': atom, 'fn:true()': atom
|
||||
};
|
||||
|
||||
// a list of 'basic' keywords. For each add a property to kwObj with the value of
|
||||
// {type: basic[i], style: "keyword"} e.g. 'after' --> {type: "after", style: "keyword"}
|
||||
var basic = ['after','ancestor','ancestor-or-self','and','as','ascending','assert','attribute','before',
|
||||
'by','case','cast','child','comment','declare','default','define','descendant','descendant-or-self',
|
||||
'descending','document','document-node','element','else','eq','every','except','external','following',
|
||||
'following-sibling','follows','for','function','if','import','in','instance','intersect','item',
|
||||
'let','module','namespace','node','node','of','only','or','order','parent','precedes','preceding',
|
||||
'preceding-sibling','processing-instruction','ref','return','returns','satisfies','schema','schema-element',
|
||||
'self','some','sortby','stable','text','then','to','treat','typeswitch','union','variable','version','where',
|
||||
'xquery', 'empty-sequence'];
|
||||
for(var i=0, l=basic.length; i < l; i++) { kwObj[basic[i]] = kw(basic[i]);};
|
||||
|
||||
// a list of types. For each add a property to kwObj with the value of
|
||||
// {type: "atom", style: "atom"}
|
||||
var types = ['xs:string', 'xs:float', 'xs:decimal', 'xs:double', 'xs:integer', 'xs:boolean', 'xs:date', 'xs:dateTime',
|
||||
'xs:time', 'xs:duration', 'xs:dayTimeDuration', 'xs:time', 'xs:yearMonthDuration', 'numeric', 'xs:hexBinary',
|
||||
'xs:base64Binary', 'xs:anyURI', 'xs:QName', 'xs:byte','xs:boolean','xs:anyURI','xf:yearMonthDuration'];
|
||||
for(var i=0, l=types.length; i < l; i++) { kwObj[types[i]] = atom;};
|
||||
|
||||
// each operator will add a property to kwObj with value of {type: "operator", style: "keyword"}
|
||||
var operators = ['eq', 'ne', 'lt', 'le', 'gt', 'ge', ':=', '=', '>', '>=', '<', '<=', '.', '|', '?', 'and', 'or', 'div', 'idiv', 'mod', '*', '/', '+', '-'];
|
||||
for(var i=0, l=operators.length; i < l; i++) { kwObj[operators[i]] = operator;};
|
||||
|
||||
// each axis_specifiers will add a property to kwObj with value of {type: "axis_specifier", style: "qualifier"}
|
||||
var axis_specifiers = ["self::", "attribute::", "child::", "descendant::", "descendant-or-self::", "parent::",
|
||||
"ancestor::", "ancestor-or-self::", "following::", "preceding::", "following-sibling::", "preceding-sibling::"];
|
||||
for(var i=0, l=axis_specifiers.length; i < l; i++) { kwObj[axis_specifiers[i]] = qualifier; };
|
||||
|
||||
return kwObj;
|
||||
}();
|
||||
|
||||
function chain(stream, state, f) {
|
||||
state.tokenize = f;
|
||||
return f(stream, state);
|
||||
}
|
||||
|
||||
// the primary mode tokenizer
|
||||
function tokenBase(stream, state) {
|
||||
var ch = stream.next(),
|
||||
mightBeFunction = false,
|
||||
isEQName = isEQNameAhead(stream);
|
||||
|
||||
// an XML tag (if not in some sub, chained tokenizer)
|
||||
if (ch == "<") {
|
||||
if(stream.match("!--", true))
|
||||
return chain(stream, state, tokenXMLComment);
|
||||
|
||||
if(stream.match("![CDATA", false)) {
|
||||
state.tokenize = tokenCDATA;
|
||||
return "tag";
|
||||
}
|
||||
|
||||
if(stream.match("?", false)) {
|
||||
return chain(stream, state, tokenPreProcessing);
|
||||
}
|
||||
|
||||
var isclose = stream.eat("/");
|
||||
stream.eatSpace();
|
||||
var tagName = "", c;
|
||||
while ((c = stream.eat(/[^\s\u00a0=<>\"\'\/?]/))) tagName += c;
|
||||
|
||||
return chain(stream, state, tokenTag(tagName, isclose));
|
||||
}
|
||||
// start code block
|
||||
else if(ch == "{") {
|
||||
pushStateStack(state,{ type: "codeblock"});
|
||||
return null;
|
||||
}
|
||||
// end code block
|
||||
else if(ch == "}") {
|
||||
popStateStack(state);
|
||||
return null;
|
||||
}
|
||||
// if we're in an XML block
|
||||
else if(isInXmlBlock(state)) {
|
||||
if(ch == ">")
|
||||
return "tag";
|
||||
else if(ch == "/" && stream.eat(">")) {
|
||||
popStateStack(state);
|
||||
return "tag";
|
||||
}
|
||||
else
|
||||
return "variable";
|
||||
}
|
||||
// if a number
|
||||
else if (/\d/.test(ch)) {
|
||||
stream.match(/^\d*(?:\.\d*)?(?:E[+\-]?\d+)?/);
|
||||
return "atom";
|
||||
}
|
||||
// comment start
|
||||
else if (ch === "(" && stream.eat(":")) {
|
||||
pushStateStack(state, { type: "comment"});
|
||||
return chain(stream, state, tokenComment);
|
||||
}
|
||||
// quoted string
|
||||
else if ( !isEQName && (ch === '"' || ch === "'"))
|
||||
return chain(stream, state, tokenString(ch));
|
||||
// variable
|
||||
else if(ch === "$") {
|
||||
return chain(stream, state, tokenVariable);
|
||||
}
|
||||
// assignment
|
||||
else if(ch ===":" && stream.eat("=")) {
|
||||
return "keyword";
|
||||
}
|
||||
// open paren
|
||||
else if(ch === "(") {
|
||||
pushStateStack(state, { type: "paren"});
|
||||
return null;
|
||||
}
|
||||
// close paren
|
||||
else if(ch === ")") {
|
||||
popStateStack(state);
|
||||
return null;
|
||||
}
|
||||
// open paren
|
||||
else if(ch === "[") {
|
||||
pushStateStack(state, { type: "bracket"});
|
||||
return null;
|
||||
}
|
||||
// close paren
|
||||
else if(ch === "]") {
|
||||
popStateStack(state);
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
var known = keywords.propertyIsEnumerable(ch) && keywords[ch];
|
||||
|
||||
// if there's a EQName ahead, consume the rest of the string portion, it's likely a function
|
||||
if(isEQName && ch === '\"') while(stream.next() !== '"'){}
|
||||
if(isEQName && ch === '\'') while(stream.next() !== '\''){}
|
||||
|
||||
// gobble up a word if the character is not known
|
||||
if(!known) stream.eatWhile(/[\w\$_-]/);
|
||||
|
||||
// gobble a colon in the case that is a lib func type call fn:doc
|
||||
var foundColon = stream.eat(":");
|
||||
|
||||
// if there's not a second colon, gobble another word. Otherwise, it's probably an axis specifier
|
||||
// which should get matched as a keyword
|
||||
if(!stream.eat(":") && foundColon) {
|
||||
stream.eatWhile(/[\w\$_-]/);
|
||||
}
|
||||
// if the next non whitespace character is an open paren, this is probably a function (if not a keyword of other sort)
|
||||
if(stream.match(/^[ \t]*\(/, false)) {
|
||||
mightBeFunction = true;
|
||||
}
|
||||
// is the word a keyword?
|
||||
var word = stream.current();
|
||||
known = keywords.propertyIsEnumerable(word) && keywords[word];
|
||||
|
||||
// if we think it's a function call but not yet known,
|
||||
// set style to variable for now for lack of something better
|
||||
if(mightBeFunction && !known) known = {type: "function_call", style: "variable def"};
|
||||
|
||||
// if the previous word was element, attribute, axis specifier, this word should be the name of that
|
||||
if(isInXmlConstructor(state)) {
|
||||
popStateStack(state);
|
||||
return "variable";
|
||||
}
|
||||
// as previously checked, if the word is element,attribute, axis specifier, call it an "xmlconstructor" and
|
||||
// push the stack so we know to look for it on the next word
|
||||
if(word == "element" || word == "attribute" || known.type == "axis_specifier") pushStateStack(state, {type: "xmlconstructor"});
|
||||
|
||||
// if the word is known, return the details of that else just call this a generic 'word'
|
||||
return known ? known.style : "variable";
|
||||
}
|
||||
}
|
||||
|
||||
// handle comments, including nested
|
||||
function tokenComment(stream, state) {
|
||||
var maybeEnd = false, maybeNested = false, nestedCount = 0, ch;
|
||||
while (ch = stream.next()) {
|
||||
if (ch == ")" && maybeEnd) {
|
||||
if(nestedCount > 0)
|
||||
nestedCount--;
|
||||
else {
|
||||
popStateStack(state);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if(ch == ":" && maybeNested) {
|
||||
nestedCount++;
|
||||
}
|
||||
maybeEnd = (ch == ":");
|
||||
maybeNested = (ch == "(");
|
||||
}
|
||||
|
||||
return "comment";
|
||||
}
|
||||
|
||||
// tokenizer for string literals
|
||||
// optionally pass a tokenizer function to set state.tokenize back to when finished
|
||||
function tokenString(quote, f) {
|
||||
return function(stream, state) {
|
||||
var ch;
|
||||
|
||||
if(isInString(state) && stream.current() == quote) {
|
||||
popStateStack(state);
|
||||
if(f) state.tokenize = f;
|
||||
return "string";
|
||||
}
|
||||
|
||||
pushStateStack(state, { type: "string", name: quote, tokenize: tokenString(quote, f) });
|
||||
|
||||
// if we're in a string and in an XML block, allow an embedded code block
|
||||
if(stream.match("{", false) && isInXmlAttributeBlock(state)) {
|
||||
state.tokenize = tokenBase;
|
||||
return "string";
|
||||
}
|
||||
|
||||
|
||||
while (ch = stream.next()) {
|
||||
if (ch == quote) {
|
||||
popStateStack(state);
|
||||
if(f) state.tokenize = f;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
// if we're in a string and in an XML block, allow an embedded code block in an attribute
|
||||
if(stream.match("{", false) && isInXmlAttributeBlock(state)) {
|
||||
state.tokenize = tokenBase;
|
||||
return "string";
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return "string";
|
||||
};
|
||||
}
|
||||
|
||||
// tokenizer for variables
|
||||
function tokenVariable(stream, state) {
|
||||
var isVariableChar = /[\w\$_-]/;
|
||||
|
||||
// a variable may start with a quoted EQName so if the next character is quote, consume to the next quote
|
||||
if(stream.eat("\"")) {
|
||||
while(stream.next() !== '\"'){};
|
||||
stream.eat(":");
|
||||
} else {
|
||||
stream.eatWhile(isVariableChar);
|
||||
if(!stream.match(":=", false)) stream.eat(":");
|
||||
}
|
||||
stream.eatWhile(isVariableChar);
|
||||
state.tokenize = tokenBase;
|
||||
return "variable";
|
||||
}
|
||||
|
||||
// tokenizer for XML tags
|
||||
function tokenTag(name, isclose) {
|
||||
return function(stream, state) {
|
||||
stream.eatSpace();
|
||||
if(isclose && stream.eat(">")) {
|
||||
popStateStack(state);
|
||||
state.tokenize = tokenBase;
|
||||
return "tag";
|
||||
}
|
||||
// self closing tag without attributes?
|
||||
if(!stream.eat("/"))
|
||||
pushStateStack(state, { type: "tag", name: name, tokenize: tokenBase});
|
||||
if(!stream.eat(">")) {
|
||||
state.tokenize = tokenAttribute;
|
||||
return "tag";
|
||||
}
|
||||
else {
|
||||
state.tokenize = tokenBase;
|
||||
}
|
||||
return "tag";
|
||||
};
|
||||
}
|
||||
|
||||
// tokenizer for XML attributes
|
||||
function tokenAttribute(stream, state) {
|
||||
var ch = stream.next();
|
||||
|
||||
if(ch == "/" && stream.eat(">")) {
|
||||
if(isInXmlAttributeBlock(state)) popStateStack(state);
|
||||
if(isInXmlBlock(state)) popStateStack(state);
|
||||
return "tag";
|
||||
}
|
||||
if(ch == ">") {
|
||||
if(isInXmlAttributeBlock(state)) popStateStack(state);
|
||||
return "tag";
|
||||
}
|
||||
if(ch == "=")
|
||||
return null;
|
||||
// quoted string
|
||||
if (ch == '"' || ch == "'")
|
||||
return chain(stream, state, tokenString(ch, tokenAttribute));
|
||||
|
||||
if(!isInXmlAttributeBlock(state))
|
||||
pushStateStack(state, { type: "attribute", tokenize: tokenAttribute});
|
||||
|
||||
stream.eat(/[a-zA-Z_:]/);
|
||||
stream.eatWhile(/[-a-zA-Z0-9_:.]/);
|
||||
stream.eatSpace();
|
||||
|
||||
// the case where the attribute has not value and the tag was closed
|
||||
if(stream.match(">", false) || stream.match("/", false)) {
|
||||
popStateStack(state);
|
||||
state.tokenize = tokenBase;
|
||||
}
|
||||
|
||||
return "attribute";
|
||||
}
|
||||
|
||||
// handle comments, including nested
|
||||
function tokenXMLComment(stream, state) {
|
||||
var ch;
|
||||
while (ch = stream.next()) {
|
||||
if (ch == "-" && stream.match("->", true)) {
|
||||
state.tokenize = tokenBase;
|
||||
return "comment";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// handle CDATA
|
||||
function tokenCDATA(stream, state) {
|
||||
var ch;
|
||||
while (ch = stream.next()) {
|
||||
if (ch == "]" && stream.match("]", true)) {
|
||||
state.tokenize = tokenBase;
|
||||
return "comment";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// handle preprocessing instructions
|
||||
function tokenPreProcessing(stream, state) {
|
||||
var ch;
|
||||
while (ch = stream.next()) {
|
||||
if (ch == "?" && stream.match(">", true)) {
|
||||
state.tokenize = tokenBase;
|
||||
return "comment meta";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// functions to test the current context of the state
|
||||
function isInXmlBlock(state) { return isIn(state, "tag"); }
|
||||
function isInXmlAttributeBlock(state) { return isIn(state, "attribute"); }
|
||||
function isInXmlConstructor(state) { return isIn(state, "xmlconstructor"); }
|
||||
function isInString(state) { return isIn(state, "string"); }
|
||||
|
||||
function isEQNameAhead(stream) {
|
||||
// assume we've already eaten a quote (")
|
||||
if(stream.current() === '"')
|
||||
return stream.match(/^[^\"]+\"\:/, false);
|
||||
else if(stream.current() === '\'')
|
||||
return stream.match(/^[^\"]+\'\:/, false);
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
function isIn(state, type) {
|
||||
return (state.stack.length && state.stack[state.stack.length - 1].type == type);
|
||||
}
|
||||
|
||||
function pushStateStack(state, newState) {
|
||||
state.stack.push(newState);
|
||||
}
|
||||
|
||||
function popStateStack(state) {
|
||||
state.stack.pop();
|
||||
var reinstateTokenize = state.stack.length && state.stack[state.stack.length-1].tokenize;
|
||||
state.tokenize = reinstateTokenize || tokenBase;
|
||||
}
|
||||
|
||||
// the interface for the mode API
|
||||
return {
|
||||
startState: function() {
|
||||
return {
|
||||
tokenize: tokenBase,
|
||||
cc: [],
|
||||
stack: []
|
||||
};
|
||||
},
|
||||
|
||||
token: function(stream, state) {
|
||||
if (stream.eatSpace()) return null;
|
||||
var style = state.tokenize(stream, state);
|
||||
return style;
|
||||
},
|
||||
|
||||
blockCommentStart: "(:",
|
||||
blockCommentEnd: ":)"
|
||||
|
||||
};
|
||||
|
||||
});
|
||||
|
||||
CodeMirror.defineMIME("application/xquery", "xquery");
|
||||
|
||||
});
|
Loading…
Add table
Add a link
Reference in a new issue