You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@marmotta.apache.org by ss...@apache.org on 2013/07/09 11:51:07 UTC
[26/41] - moved SNORQL to WebJar - moved CodeMirror to WebJar - moved
Sgvizler to WebJar - cleaned up uses of non-webjar jquery and jquery-ui -
configured YUI compressor for the above packages in build
http://git-wip-us.apache.org/repos/asf/incubator-marmotta/blob/5fd590b4/extras/webjars/snorql/src/main/resources/snorql.js
----------------------------------------------------------------------
diff --git a/extras/webjars/snorql/src/main/resources/snorql.js b/extras/webjars/snorql/src/main/resources/snorql.js
new file mode 100755
index 0000000..620fa1e
--- /dev/null
+++ b/extras/webjars/snorql/src/main/resources/snorql.js
@@ -0,0 +1,591 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+var snorql = new Snorql();
+
+String.prototype.trim = function () {
+ return this.replace(/^\s*/, "").replace(/\s*$/, "");
+}
+
+String.prototype.startsWith = function(str) {
+ return (this.match("^"+str) == str);
+}
+
+function Snorql() {
+ // modify this._endpoint to point to your SPARQL endpoint
+ this._endpoint = _BASIC_URL + 'sparql/select';
+ // modify these to your liking
+ this._poweredByLink = 'http://marmotta.incubator.apache.org';
+ this._poweredByLabel = 'Snorql & Apache Marmotta';
+ this._enableNamedGraphs = false;
+
+ this._browserBase = null;
+ this._namespaces = {};
+ this._graph = null;
+ this._xsltDOM = null;
+
+ this.start = function() {
+ // TODO: Extract a QueryType class
+ this.setBrowserBase(document.location.href.replace(/\?.*/, ''));
+ this._displayEndpointURL();
+ //this._displayPoweredBy();
+ this.updateOutputMode();
+ var match = document.location.href.match(/\?(.*)/);
+ var queryString = match ? match[1] : '';
+ if (!queryString) {
+ document.getElementById('querytext').value = 'SELECT * WHERE {\n ?s ?p ?o\n}\nLIMIT 10';
+ this._updateGraph(null, false);
+ return;
+ }
+
+ var graph = queryString.match(/graph=([^&]*)/);
+ graph = graph ? decodeURIComponent(graph[1]) : null;
+ this._updateGraph(graph, false);
+
+ var browse = queryString.match(/browse=([^&]*)/);
+ if (browse) {
+ if (browse[1] == 'classes') {
+ var resultTitle = 'List of all classes:';
+ var query = 'SELECT DISTINCT ?class\n' +
+ 'WHERE { [] a ?class }\n' +
+ 'ORDER BY ?class';
+ } else if (browse[1] == 'properties') {
+ var resultTitle = 'List of all properties:';
+ var query = 'SELECT DISTINCT ?property\n' +
+ 'WHERE { [] ?property [] }\n' +
+ 'ORDER BY ?property';
+ } else if (browse[1] == 'graphs') {
+ var resultTitle = 'List of all named graphs:';
+ var query = 'SELECT DISTINCT ?namedgraph ?label\n' +
+ 'WHERE {\n' +
+ ' GRAPH ?namedgraph { ?s ?p ?o }\n' +
+ ' OPTIONAL { ?namedgraph rdfs:label ?label }\n' +
+ '}\n' +
+ 'ORDER BY ?namedgraph';
+ }
+ }
+
+ var properties = queryString.match(/property=([^&]*)/);
+ if (properties) {
+ var resultTitle = 'All uses of property ' + decodeURIComponent(properties[1]) + ':';
+ var query = 'SELECT DISTINCT ?resource ?value\n' +
+ 'WHERE { ?resource <' + decodeURIComponent(properties[1]) + '> ?value }\n' +
+ 'ORDER BY ?resource ?value';
+ }
+
+ var classes = queryString.match(/class=([^&]*)/);
+ if (classes) {
+ var resultTitle = 'All instances of class ' + decodeURIComponent(classes[1]) + ':';
+ var query = 'SELECT DISTINCT ?instance\n' +
+ 'WHERE { ?instance a <' + decodeURIComponent(classes[1]) + '> }\n' +
+ 'ORDER BY ?instance';
+ }
+
+ var describe = queryString.match(/describe=([^&]*)/);
+ if (describe) {
+ var resultTitle = 'Description of ' + decodeURIComponent(describe[1]) + ':';
+ var query = 'SELECT DISTINCT ?property ?hasValue ?isValueOf\n' +
+ 'WHERE {\n' +
+ ' { <' + decodeURIComponent(describe[1]) + '> ?property ?hasValue }\n' +
+ ' UNION\n' +
+ ' { ?isValueOf ?property <' + decodeURIComponent(describe[1]) + '> }\n' +
+ '}\n' +
+ 'ORDER BY (!BOUND(?hasValue)) ?property ?hasValue ?isValueOf';
+ }
+
+ var queryMatch = queryString.match(/query=([^&]*)/);
+ if (queryMatch) {
+ var resultTitle = 'SPARQL results:';
+ var query = this._betterUnescape(queryMatch[1]);
+
+ }
+
+ var prefixes = this._getPrefixes();
+ if (queryString.match(/prefixes=/)) {
+ prefixes = this._betterUnescape(queryString.match(/prefixes=([^&]*)/)[1]);
+ }
+
+ var querytext = prefixes + " " + query;
+ document.getElementById('querytext').value = query;
+ this.displayBusyMessage();
+ var service = new SPARQL.Service(this._endpoint);
+ if (this._graph) {
+ service.addDefaultGraph(this._graph);
+ }
+
+ // AndyL changed MIME type and success callback depending on query form...
+ var dummy = this;
+
+ var exp = /^\s*(?:PREFIX\s+\w*:\s+<[^>]*>\s*)*(\w+)\s*.*/i;
+ var match = exp.exec(query);
+ if (match) {
+ if (match[1].toUpperCase() == 'ASK') {
+ service.setOutput('boolean');
+ var successFunc = function(value) {
+ dummy.displayBooleanResult(value, resultTitle);
+ };
+ } else if (match[1].toUpperCase() == 'CONSTRUCT' || match[1].toUpperCase() == 'DESCRIBE'){ // construct describe
+ service.setOutput('rdf'); // !json
+ var successFunc = function(model) {
+ dummy.displayRDFResult(model, resultTitle);
+ };
+ } else {
+ service.setRequestHeader('Accept', 'application/sparql-results+json,*/*');
+ service.setOutput('json');
+ var successFunc = function(json) {
+ dummy.displayJSONResult(json, resultTitle);
+ };
+ }
+ }
+
+ service.query(querytext, {
+ success: successFunc,
+ failure: function(report) {
+ var message = report.responseText.match(/<pre>([\s\S]*)<\/pre>/);
+ if (message) {
+ dummy.displayErrorMessage(message[1]);
+ } else {
+ dummy.displayErrorMessage(report.responseText);
+ }
+ }
+ });
+ }
+
+ this.setBrowserBase = function(url) {
+ this._browserBase = url;
+ }
+
+ this._displayEndpointURL = function() {
+ var title = document.createElement("span");
+ title.innerHTML = 'Querying <a href="' + this._endpoint + '">' + this._endpoint + '</a>';
+ this._display(title, 'title');
+ document.title = "Querying " + this._endpoint;
+ }
+
+ this._displayPoweredBy = function() {
+ $('poweredby').href = this._poweredByLink;
+ $('poweredby').update(this._poweredByLabel);
+ }
+
+ this.setNamespaces = function(namespaces) {
+ this._namespaces = namespaces;
+ var prefixes = this._getPrefixes();
+ document.getElementById('prefixes').value = prefixes;
+ this._display(document.createTextNode(prefixes), 'prefixestext');
+ }
+
+ this.switchToGraph = function(uri) {
+ this._updateGraph(uri, true);
+ }
+
+ this.switchToDefaultGraph = function() {
+ this._updateGraph(null, true);
+ }
+
+ this._updateGraph = function(uri, effect) {
+ if (!this._enableNamedGraphs) {
+ $('default-graph-section').hide();
+ $('named-graph-section').hide();
+ $('browse-named-graphs-link').hide();
+ return;
+ }
+ var changed = (uri != this._graph);
+ this._graph = uri;
+ var el = document.getElementById('graph-uri');
+ el.disabled = (this._graph == null);
+ el.value = this._graph;
+ if (this._graph == null) {
+ var show = 'default-graph-section';
+ var hide = 'named-graph-section';
+ $$('a.graph-link').each(function(link) {
+ match = link.href.match(/^(.*)[&?]graph=/);
+ if (match) link.href = match[1];
+ });
+ } else {
+ var show = 'named-graph-section';
+ var hide = 'default-graph-section';
+ $('selected-named-graph').update(this._graph);
+ var uri = this._graph;
+ $$('a.graph-link').each(function(link) {
+ match = link.href.match(/^(.*)[&?]graph=/);
+ if (!match) link.href = link.href + '&graph=' + uri;
+ });
+ }
+ $(hide).hide();
+ $(show).show();
+ if (effect && changed) {
+ new Effect.Highlight(show,
+ {startcolor: '#ffff00', endcolor: '#ccccff', resotrecolor: '#ccccff'});
+ }
+ $('graph-uri').disabled = (this._graph == null);
+ $('graph-uri').value = this._graph;
+ }
+
+ this.updateOutputMode = function() {
+ if (this._xsltDOM == null) {
+ this._xsltDOM = document.getElementById('xsltinput');
+ }
+ var el = document.getElementById('xsltcontainer');
+ while (el.childNodes.length > 0) {
+ el.removeChild(el.firstChild);
+ }
+ if (this._selectedOutputMode() == 'xslt') {
+ el.appendChild(this._xsltDOM);
+ }
+ }
+
+ this.resetQuery = function() {
+ document.location = this._browserBase;
+ }
+
+ this.submitQuery = function() {
+ var mode = this._selectedOutputMode();
+ if (mode == 'browse') {
+ document.getElementById('queryform').action = this._browserBase;
+ } else {
+ document.getElementById('queryform').action = this._endpoint;
+ }
+ document.getElementById('query').value = document.getElementById('querytext').value;
+ document.getElementById('jsonoutput').disabled = (mode != 'json');
+ if(mode == 'html') {
+ document.getElementById('jsonoutput').disabled = false;
+ document.getElementById('jsonoutput').value = 'html';
+ } else if(mode == 'csv') {
+ document.getElementById('jsonoutput').disabled = false;
+ document.getElementById('jsonoutput').value = 'csv';
+ } else if(mode == 'xml') {
+ document.getElementById('jsonoutput').disabled = false;
+ document.getElementById('jsonoutput').value = 'xml';
+ } else {
+ document.getElementById('jsonoutput').value = 'json';
+ }
+ document.getElementById('stylesheet').disabled = (mode != 'xslt' || !document.getElementById('xsltstylesheet').value);
+ if (mode == 'xslt') {
+ document.getElementById('stylesheet').value = document.getElementById('xsltstylesheet').value;
+ }
+ document.getElementById('queryform').submit();
+ }
+
+ this.displayBusyMessage = function() {
+ var busy = document.createElement('div');
+ busy.className = 'busy';
+ busy.appendChild(document.createTextNode('Executing query ...'));
+ this._display(busy, 'result');
+ }
+
+ this.displayErrorMessage = function(message) {
+ var pre = document.createElement('pre');
+ pre.innerHTML = message;
+ this._display(pre, 'result');
+ }
+
+ this.displayBooleanResult = function(value, resultTitle) {
+ var div = document.createElement('div');
+ var title = document.createElement('h2');
+ title.appendChild(document.createTextNode(resultTitle));
+ div.appendChild(title);
+ if (value)
+ div.appendChild(document.createTextNode("TRUE"));
+ else
+ div.appendChild(document.createTextNode("FALSE"));
+ this._display(div, 'result');
+ this._updateGraph(this._graph); // refresh links in new result
+ }
+
+ this.displayRDFResult = function(model, resultTitle) {
+ var div = document.createElement('div');
+ var title = document.createElement('h2');
+ title.appendChild(document.createTextNode(resultTitle));
+ div.appendChild(title);
+ div.appendChild(new RDFXMLFormatter(model));
+ this._display(div, 'result');
+ this._updateGraph(this._graph); // refresh links in new result - necessary for boolean?
+ }
+
+ this.displayCSVResult = function(model, resultTitle) {
+ var div = document.createElement('div');
+ var title = document.createElement('h2');
+ title.appendChild(document.createTextNode(resultTitle));
+ div.appendChild(title);
+ div.appendChild(new RDFCSVFormatter(model));
+ this._display(div, 'result');
+ this._updateGraph(this._graph); // refresh links in new result - necessary for boolean?
+ }
+
+ this.displayJSONResult = function(json, resultTitle) {
+ var div = document.createElement('div');
+ var title = document.createElement('h2');
+ title.appendChild(document.createTextNode(resultTitle));
+ div.appendChild(title);
+ if (json.results.bindings.length == 0) {
+ var p = document.createElement('p');
+ p.className = 'empty';
+ p.appendChild(document.createTextNode('[no results]'));
+ div.appendChild(p);
+ } else {
+ div.appendChild(new SPARQLResultFormatter(json, this._namespaces).toDOM());
+ }
+ this._display(div, 'result');
+ this._updateGraph(this._graph); // refresh links in new result
+ }
+
+ this._display = function(node, whereID) {
+ var where = document.getElementById(whereID);
+ if(whereID=='result')where.style.display='block';
+ if (!where) {
+ alert('ID not found: ' + whereID);
+ return;
+ }
+ while (where.firstChild) {
+ where.removeChild(where.firstChild);
+ }
+ if (node == null) return;
+ where.appendChild(node);
+ }
+
+ this._selectedOutputMode = function() {
+ return document.getElementById('selectoutput').value;
+ }
+
+ this._getPrefixes = function() {
+ prefixes = '';
+ for (prefix in this._namespaces) {
+ var uri = this._namespaces[prefix];
+ prefixes = prefixes + 'PREFIX ' + prefix + ': <' + uri + '>\n';
+ }
+ return prefixes;
+ }
+
+ this._betterUnescape = function(s) {
+ return unescape(s.replace(/\+/g, ' '));
+ }
+}
+
+/*
+ * RDFXMLFormatter
+ *
+ * maybe improve...
+ */
+function RDFXMLFormatter(string) {
+ var pre = document.createElement('pre');
+ pre.appendChild(document.createTextNode(string));
+ return pre;
+}
+
+function RDFCSVFormatter(string) {
+ var pre = document.createElement('pre');
+ pre.appendChild(document.createTextNode(string));
+ return pre;
+}
+
+
+/*
+===========================================================================
+SPARQLResultFormatter: Renders a SPARQL/JSON result set into an HTML table.
+
+var namespaces = { 'xsd': '', 'foaf': 'http://xmlns.com/foaf/0.1' };
+var formatter = new SPARQLResultFormatter(json, namespaces);
+var tableObject = formatter.toDOM();
+*/
+function SPARQLResultFormatter(json, namespaces) {
+ this._json = json;
+ this._variables = this._json.head.vars;
+ this._results = this._json.results.bindings;
+ this._namespaces = namespaces;
+
+ this.toDOM = function() {
+ var table = document.createElement('table');
+ table.className = 'queryresults';
+ table.appendChild(this._createTableHeader());
+ for (var i = 0; i < this._results.length; i++) {
+ table.appendChild(this._createTableRow(this._results[i], i));
+ }
+ return table;
+ }
+
+ // TODO: Refactor; non-standard link makers should be passed into the class by the caller
+ this._getLinkMaker = function(varName) {
+ if (varName == 'property') {
+ return function(uri) { return '?property=' + encodeURIComponent(uri); };
+ } else if (varName == 'class') {
+ return function(uri) { return '?class=' + encodeURIComponent(uri); };
+ } else {
+ return function(uri) { return '?describe=' + encodeURIComponent(uri); };
+ }
+ }
+
+ this._createTableHeader = function() {
+ var tr = document.createElement('tr');
+ var hasNamedGraph = false;
+ for (var i = 0; i < this._variables.length; i++) {
+ var th = document.createElement('th');
+ th.appendChild(document.createTextNode(this._variables[i]));
+ tr.appendChild(th);
+ if (this._variables[i] == 'namedgraph') {
+ hasNamedGraph = true;
+ }
+ }
+ if (hasNamedGraph) {
+ var th = document.createElement('th');
+ th.appendChild(document.createTextNode(' '));
+ tr.insertBefore(th, tr.firstChild);
+ }
+ return tr;
+ }
+
+ this._createTableRow = function(binding, rowNumber) {
+ var tr = document.createElement('tr');
+ if (rowNumber % 2) {
+ tr.className = 'odd';
+ } else {
+ tr.className = 'even';
+ }
+ var namedGraph = null;
+ for (var i = 0; i < this._variables.length; i++) {
+ var varName = this._variables[i];
+ td = document.createElement('td');
+ td.appendChild(this._formatNode(binding[varName], varName));
+ tr.appendChild(td);
+ if (this._variables[i] == 'namedgraph') {
+ namedGraph = binding[varName];
+ }
+ }
+ if (namedGraph) {
+ var link = document.createElement('a');
+ link.href = 'javascript:snorql.switchToGraph(\'' + namedGraph.value + '\')';
+ link.appendChild(document.createTextNode('Switch'));
+ var td = document.createElement('td');
+ td.appendChild(link);
+ tr.insertBefore(td, tr.firstChild);
+ }
+ return tr;
+ }
+
+ this._formatNode = function(node, varName) {
+ if (!node) {
+ return this._formatUnbound(node, varName);
+ }
+ if (node.type == 'uri') {
+ return this._formatURI(node, varName);
+ }
+ if (node.type == 'bnode') {
+ return this._formatBlankNode(node, varName);
+ }
+ if (node.type == 'literal') {
+ return this._formatPlainLiteral(node, varName);
+ }
+ if (node.type == 'typed-literal') {
+ return this._formatTypedLiteral(node, varName);
+ }
+ return document.createTextNode('???');
+ }
+
+ this._formatURI = function(node, varName) {
+ var span = document.createElement('span');
+ span.className = 'uri';
+ var a = document.createElement('a');
+ a.href = this._getLinkMaker(varName)(node.value);
+ a.title = '<' + node.value + '>';
+ a.className = 'graph-link';
+ var qname = this._toQName(node.value);
+ if (qname) {
+ a.appendChild(document.createTextNode(qname));
+ span.appendChild(a);
+ } else {
+ a.appendChild(document.createTextNode(node.value));
+ span.appendChild(document.createTextNode('<'));
+ span.appendChild(a);
+ span.appendChild(document.createTextNode('>'));
+ }
+ match = node.value.match(/^(https?|ftp|mailto|irc|gopher|news):/);
+ if (match) {
+ span.appendChild(document.createTextNode(' '));
+ var externalLink = document.createElement('a');
+ externalLink.href = node.value;
+ img = document.createElement('img');
+ img.src = 'link.png';
+ img.alt = '[' + match[1] + ']';
+ img.title = 'Go to URI directly';
+ externalLink.appendChild(img);
+ span.appendChild(externalLink);
+ }
+ return span;
+ }
+
+ this._formatPlainLiteral = function(node, varName) {
+ var text = '"' + node.value + '"';
+ if (node['xml:lang']) {
+ text += '@' + node['xml:lang'];
+ }
+ return document.createTextNode(text);
+ }
+
+ this._formatTypedLiteral = function(node, varName) {
+ var text = '"' + node.value + '"';
+ if (node.datatype) {
+ text += '^^' + this._toQNameOrURI(node.datatype);
+ }
+ if (this._isNumericXSDType(node.datatype)) {
+ var span = document.createElement('span');
+ span.title = text;
+ span.appendChild(document.createTextNode(node.value));
+ return span;
+ }
+ return document.createTextNode(text);
+ }
+
+ this._formatBlankNode = function(node, varName) {
+ return document.createTextNode('_:' + node.value);
+ }
+
+ this._formatUnbound = function(node, varName) {
+ var span = document.createElement('span');
+ span.className = 'unbound';
+ span.title = 'Unbound'
+ span.appendChild(document.createTextNode('-'));
+ return span;
+ }
+
+ this._toQName = function(uri) {
+ for (prefix in this._namespaces) {
+ var nsURI = this._namespaces[prefix];
+ if (uri.indexOf(nsURI) == 0) {
+ return prefix + ':' + uri.substring(nsURI.length);
+ }
+ }
+ return null;
+ }
+
+ this._toQNameOrURI = function(uri) {
+ var qName = this._toQName(uri);
+ return (qName == null) ? '<' + uri + '>' : qName;
+ }
+
+ this._isNumericXSDType = function(datatypeURI) {
+ for (i = 0; i < this._numericXSDTypes.length; i++) {
+ if (datatypeURI == this._xsdNamespace + this._numericXSDTypes[i]) {
+ return true;
+ }
+ }
+ return false;
+ }
+ this._xsdNamespace = 'http://www.w3.org/2001/XMLSchema#';
+ this._numericXSDTypes = ['long', 'decimal', 'float', 'double', 'int',
+ 'short', 'byte', 'integer', 'nonPositiveInteger', 'negativeInteger',
+ 'nonNegativeInteger', 'positiveInteger', 'unsignedLong',
+ 'unsignedInt', 'unsignedShort', 'unsignedByte'];
+}
http://git-wip-us.apache.org/repos/asf/incubator-marmotta/blob/5fd590b4/extras/webjars/snorql/src/main/resources/sparql.js
----------------------------------------------------------------------
diff --git a/extras/webjars/snorql/src/main/resources/sparql.js b/extras/webjars/snorql/src/main/resources/sparql.js
new file mode 100755
index 0000000..2b34538
--- /dev/null
+++ b/extras/webjars/snorql/src/main/resources/sparql.js
@@ -0,0 +1,507 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+/**********************************************************
+ Copyright (c) 2006, 2007
+ Lee Feigenbaum ( lee AT thefigtrees DOT net )
+ Elias Torres ( elias AT torrez DOT us )
+ Wing Yung ( wingerz AT gmail DOT com )
+ All rights reserved.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+**********************************************************/
+
+/**
+ * Example client interactions
+ *
+
+ var sparqler = new SPARQL.Service("http://sparql.org/sparql");
+ sparqler.addDefaultGraph("http://thefigtrees.net/lee/ldf-card"); // inherited by all (future) queries
+ sparqler.addNamedGraph("http://torrez.us/elias/foaf.rdf");
+ sparqler.setPrefix("foaf", "http://xmlns.com/foaf/0.1/"); // inherited by all (future) queries
+ sparqler.setPrefix("rdf", "http://xmlns.com/foaf/0.1/");
+
+ sparqler.setRequestHeader("Authentication", "Basic: " + basicAuthString);
+
+ //sparqler.wantOutputAs("application/json"); // for now we only do JSON
+
+ var query = sparqler.createQuery();
+ query.addDefualtGraph(...) query.addNamedGraph(...) query.setPrefix(...) query.setRequestHeader(...) // this query only
+
+ // query forms:
+
+ // passes standard JSON results object to success callback
+ query.setPrefix("ldf", "http://thefigtrees.net/lee/ldf-card#");
+ query.query("SELECT ?who ?mbox WHERE { ldf:LDF foaf:knows ?who . ?who foaf:mbox ?mbox }",
+ {failure: onFailure, success: function(json) { for (var x in json.head.vars) { ... } ...}}
+ );
+
+ // passes boolean value to success callback
+ query.ask("ASK ?person WHERE { ?person foaf:knows [ foaf:name "Dan Connolly" ] }",
+ {failure: onFailure, success: function(bool) { if (bool) ... }}
+ );
+
+ // passes a single vector (array) of values representing a single column of results to success callback
+ query.setPrefix("ldf", "http://thefigtrees.net/lee/ldf-card#");
+ var addresses = query.selectValues("SELECT ?mbox WHERE { _:someone foaf:mbox ?mbox }",
+ {failure: onFailure, success: function(values) { for (var i = 0; i < values.length; i++) { ... values[i] ...} } }
+ );
+
+ // passes a single value representing a single row of a single column (variable) to success callback
+ query.setPrefix("ldf", "http://thefigtrees.net/lee/ldf-card#");
+ var myAddress = query.selectSingleValue("SELECT ?mbox WHERE {ldf:LDF foaf:mbox ?mbox }",
+ {failure: onFailure, success: function(value) { alert("value is: " + value); } }
+ );
+
+ // shortcuts for all of the above (w/o ability to set any query-specific graphs or prefixes)
+ sparqler.query(...) sparqler.ask(...) sparqler.selectValues(...) sparqler.selectSingleValue(...)
+
+
+ */
+
+var SPARQL = {}; // SPARQL namespace
+
+
+/**
+ * Both SPARQL service objects and SPARQL query objects receive one query utility method
+ * per entry in this dictionary. The key is the name of the method, and the value is a function
+ * that transforms the standard JSON output into a more useful form. The return value of a
+ * transformation function is passed into any 'success' callback function provided when the query
+ * is issued. The following transformations are included:
+ * + query -- identity transform; returns the JSON structure unchanged
+ * + ask -- for ASK queries; returns a boolean value indicating the answer to the query
+ * + selectValues -- for SELECT queries with a single variable; returns an array containing
+ * the answers to the query
+ * + selectSingleValue -- for SELECT queries returning one column with one row; returns the
+ * value in the first (and presumably, only) cell in the resultset
+ * + selectValueArrays -- for SELECT queries returning independent columns; returns a hash
+ * keyed on variable name with values as arrays of answers for that variable. Useful
+ * for UNION queries.
+ * Note that all of the transformations that return values directly lose any type information
+ * and the ability to distinguish between URIs, blank nodes, and literals.
+ */
+SPARQL._query_transformations = {
+ query: function (o) { return o; },
+ ask: function (o) { return o["boolean"]; },
+ selectValues: function (o) {
+ var v = o.head.vars[0]; // assume one variable
+ var values = [];
+ for (var i = 0; i < o.results.bindings.length; i++)
+ values.push(o.results.bindings[i][v].value);
+ return values;
+ },
+ selectSingleValue: function(o) { return o.results.bindings[0][o.head.vars[0]].value; },
+ selectValueArrays: function(o) {
+ // factor by value (useful for UNION queries)
+ var ret = {};
+ for (var i = 0; i < o.head.vars.length; i++)
+ ret[o.head.vars[i]] = [];
+ for (var i = 0; i < o.results.bindings.length; i++)
+ for (var v in o.results.bindings[i])
+ if (ret[v] instanceof Array) ret[v].push(o.results.bindings[i][v].value);
+ return ret;
+ },
+ selectValueHashes: function(o) {
+ var hashes = [];
+ for (var i = 0; i < o.results.bindings.length; i++) {
+ var hash = {};
+ for (var v in o.results.bindings[i])
+ hash[v] = o.results.bindings[i][v].value;
+ hashes.push(hash);
+ }
+ return hashes;
+ }
+};
+
+SPARQL.statistics = {
+ queries_sent : 0,
+ successes : 0,
+ failures : 0
+};
+
+// A SPARQL service represents a single endpoint which implements the HTTP (GET or POST)
+// bindings of the SPARQL Protocol. It provides convenience methods to set dataset and
+// prefix options for all queries created for this endpoint.
+SPARQL.Service = function(endpoint) {
+ //---------------
+ // private fields
+ var _endpoint = endpoint;
+ var _default_graphs = [];
+ var _named_graphs = [];
+ var _prefix_map = {};
+ var _method = 'POST';
+ var _output = 'json';
+ var _max_simultaneous = 0;
+ var _request_headers = {};
+
+ //----------
+ // accessors
+ this.endpoint = function() { return _endpoint; };
+ this.defaultGraphs = function() { return _default_graphs; };
+ this.namedGraphs = function() { return _named_graphs; };
+ this.prefixes = function() { return _prefix_map; };
+ this.method = function() { return _method; };
+ this.output = function() { return _output; };
+ this.maxSimultaneousQueries = function() { return _max_simultaneous; };
+ this.requestHeaders = function() { return _request_headers; };
+
+ //---------
+ // mutators
+ function _add_graphs(toAdd, arr) {
+ if (toAdd instanceof Array)
+ for (var i = 0; i < toAdd.length; i++) arr.push(toAdd[i]);
+ else
+ arr.push(toAdd);
+ }
+ this.addDefaultGraph = function(g) { _add_graphs(g, this.defaultGraphs()); };
+ this.addNamedGraph = function(g) { _add_graphs(g, this.namedGraphs()); };
+ this.setPrefix = function(p, u) { this.prefixes()[p] = u; };
+ this.createQuery = function(p) { return new SPARQL.Query(this, p); };
+ this.setMethod = function(m) {
+ if (m != 'GET' && m != 'POST') throw("HTTP methods other than GET and POST are not supported.");
+ _method = m;
+ };
+ this.setOutput = function(o) { _output = o; };
+ this.setMaxSimultaneousQueries = function(m) { _max_simultaneous = m; };
+ this.setRequestHeader = function(h, v) { _request_headers[h] = v; };
+
+ //---------------
+ // protected methods (should only be called within this module
+ this._active_queries = 0;
+ this._queued_queries = [];
+ this._next_in_queue = 0;
+ this._canRun = function() { return this.maxSimultaneousQueries() <= 0 || this._active_queries < this.maxSimultaneousQueries();};
+ this._queue = function(q,f, p) {
+ if (!p) p = 0;
+ if (p > 0) {
+ for (var i = 0; i < this._queued_queries.length; i++) {
+ if (this._queued_queries[i] != null && this._queued_queries[i][2] < p) {
+ this._queued_queries.splice(i, 0, [q, f, p]);
+ return;
+ }
+ }
+ }
+ this._queued_queries.push([q,f,p]);
+ };
+ this._markRunning = function(q) { this._active_queries++; };
+ this._markDone = function(q) {
+ this._active_queries--;
+ //document.getElementById('log').innerHTML+="query done. " + this._active_queries + " queries still active.<br>";
+ if (this._queued_queries[this._next_in_queue] != null && this._canRun()) {
+ var a = this._queued_queries[this._next_in_queue];
+ this._queued_queries[this._next_in_queue++] = null;
+ // a[0] is query object, a[1] is function to run query
+ //document.getElementById('log').innerHTML += "running query from Q<br>";
+ a[1]();
+ }
+ };
+
+ //---------------
+ // public methods
+
+ // use our varied transformations to create the various shortcut methods of actually
+ // issuing queries without explicitly creating a query object
+ for (var query_form in SPARQL._query_transformations) {
+ // need the extra function to properly scope query_form (qf)
+ this[query_form] = (function(qf) {
+ return function(queryString, callback) {
+ var q = this.createQuery();
+ q._doQuery(queryString, callback, SPARQL._query_transformations[qf]);
+ };
+ })(query_form);
+ }
+
+ //------------
+ // constructor
+
+ if (!_endpoint)
+ return null;
+
+ return this;
+}
+
+/**
+ * A SPARQL query object should be created using the createQuery method of a SPARQL
+ * service object. It allows prefixes and datasets to be defined specifically for
+ * a single query, and provides introspective methods to see the query string and the
+ * full (HTTP GET) URL of the query.
+ */
+SPARQL.Query = function(service, priority) {
+ //---------------
+ // private fields
+ var _conn = null;
+ var _service = service;
+ var _default_graphs = clone_obj(service.defaultGraphs()); // prevent future updates from affecting us
+ var _named_graphs = clone_obj(service.namedGraphs());
+ var _prefix_map = clone_obj(service.prefixes());
+ var _user_query = ''; // doesn't include auto-generated prefix declarations
+ var _method = service.method();
+ var _output = service.output();
+ var _priority = priority || 0;
+ var _request_headers = clone_obj(service.requestHeaders());
+
+ //------------------
+ // private functions
+ function _create_json(text) {
+ if (!text)
+ return null;
+ // make sure this is safe JSON
+ // see: http://www.ietf.org/internet-drafts/draft-crockford-jsonorg-json-03.txt
+
+ // (1) strip out quoted strings
+ var no_strings = text.replace(/"(\\.|[^"\\])*"/g, '');
+ // (2) make sure that all the characters are explicitly part of the JSON grammar
+ // (in particular, note as discussed in the IETF submission, there are no assignments
+ // or function invocations allowed by this reg. exp.)
+ var hasBadCharacter = /[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(no_strings);
+ // (3) evaluate the JSON string, returning its contents
+ if (!hasBadCharacter) {
+ try {
+ return eval('(' + text + ')');
+ } catch (e) {
+ return null;
+ }
+ }
+ return null;
+ }
+
+ function clone_obj(o) {
+ var o2 = o instanceof Array ? [] : {};
+ for(var x in o) {o2[x] = o[x];}
+ return o2;
+ }
+
+ //----------------
+ // private methods
+ this._doCallback = function(cb, which, arg) {
+ //document.getElementById('log').innerHTML += "_doCallback ... <br>";
+ var user_data = "argument" in cb ? cb.argument : null;
+ if (which in cb) {
+ if (cb.scope) {
+ cb[which].apply(cb.scope, [arg, user_data]);
+ } else {
+ cb[which](arg, user_data);
+ }
+ }
+ }
+
+ this._queryFailure = function(xhr, arg) {
+ SPARQL.statistics.failures++;
+ _service._markDone(this);
+ this._doCallback(arg.callback, 'failure', xhr /* just pass through the connection response object */);
+ };
+ this._querySuccess = function(xhr, arg) {
+ //alert(xhr.responseText);
+ SPARQL.statistics.successes++;
+ _service._markDone(this);
+ this._doCallback(arg.callback, 'success', arg.transformer(
+ _output == 'json' ? _create_json(xhr.responseText) : xhr.responseText
+ ));
+ };
+
+ function getXmlHttpRequest(url) {
+ // right now, this only does Firefox (Opera? Safari?)
+ return new XMLHttpRequest();
+ }
+
+ this._doQuery = function(queryString, callback, transformer) {
+ _user_query = queryString;
+ if (_service._canRun()) {
+ try {
+ if (_method != 'POST' && _method != 'GET')
+ throw("HTTP methods other than GET and POST are not supported.");
+
+ var url = _method == 'GET' ? this.queryUrl() : this.service().endpoint();
+ var xhr = getXmlHttpRequest(url);
+ var content = null;
+
+ try {
+ if (!document.domain || ((url.match(/^http:\/\//) && url.slice(7, document.domain.length + 7) != document.domain || url.match(/^https:\/\//) && url.slice(8, document.domain.length + 8) != document.domain) && window.netscape && netscape.security && netscape.security.PrivilegeManager)) {
+ netscape.security.PrivilegeManager.enablePrivilege( "UniversalBrowserRead");
+ netscape.security.PrivilegeManager.enablePrivilege( "UniversalXPConnect");
+ }
+ } catch(e) {
+ alert("Cross-site requests prohibited. You will only be able to SPARQL the origin site: " + e);
+ return;
+ }
+
+ xhr.open(_method, url, true /* async */);
+
+ // set the headers, including the content-type for POSTed queries
+ for (var header in this.requestHeaders())
+ if (typeof(this.requestHeaders()[header]) != "function")
+ xhr.setRequestHeader(header, this.requestHeaders()[header]);
+ if (_method == 'POST') {
+ xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
+ content = this.queryParameters();
+ }
+
+ SPARQL.statistics.queries_sent++;
+ _service._markRunning(this);
+
+ var callbackData = {
+ scope: this,
+ success: this._querySuccess,
+ failure: this._queryFailure,
+ argument: {
+ transformer: transformer,
+ callback: callback
+ }
+ };
+
+ // I've seen some strange race-condition behavior (strange since normally
+ // JS is single-threaded, so synchronization conditions don't occur barring
+ // reentrancy) with onreadystatechange. Instead, we poll asynchronously to
+ // determine when the request is done.
+ var token = window.setInterval(
+ function () {
+ if (xhr.readyState == 4) { // ready!
+ // clear this handler
+ window.clearInterval(token);
+ // we check the status to know which callback to call
+ if (xhr.status >= 200 && xhr.status < 300)
+ callbackData.success.apply(callbackData.scope, [xhr, callbackData.argument]);
+ else
+ callbackData.failure.apply(callbackData.scope, [xhr, callbackData.argument]);
+ }
+ },
+ 200 /* maybe this should be customizable */
+ );
+
+ xhr.send(content);
+ } catch (e) {
+ alert("Error sending SPARQL query: " + e);
+ }
+ } else {
+ var self = this;
+ _service._queue(self, function() { self._doQuery(queryString, callback, transformer); }, _priority);
+ }
+ };
+
+
+ //----------
+ // accessors
+ this.request = function() { return _conn; };
+ this.service = function() { return _service; };
+ this.defaultGraphs = function() { return _default_graphs; };
+ this.namedGraphs = function() { return _named_graphs; };
+ this.prefixes = function() { return _prefix_map; };
+ this.method = function() { return _method; };
+ this.requestHeaders = function() { return _request_headers; };
+
+
+ /**
+ * Returns the SPARQL query represented by this object. The parameter, which can
+ * be omitted, determines whether or not auto-generated PREFIX clauses are included
+ * in the returned query string.
+ */
+ this.queryString = function(excludePrefixes) {
+ var preamble = '';
+ if (!excludePrefixes) {
+ for (var prefix in this.prefixes()) {
+ if(typeof(this.prefixes()[prefix]) != 'string') continue;
+ preamble += 'PREFIX ' + prefix + ': <' + this.prefixes()[prefix] + '> ';
+ }
+ }
+ return preamble + _user_query;
+ };
+
+ /**
+ * Returns the HTTP query parameters to invoke this query. This includes entries for
+ * all of the default graphs, the named graphs, the SPARQL query itself, and an
+ * output parameter to specify JSON (or other) output is desired.
+ */
+ this.queryParameters = function () {
+ var urlQueryString = '';
+ var i;
+
+ // add default and named graphs to the protocol invocation
+ for (i = 0; i < this.defaultGraphs().length; i++) urlQueryString += 'default-graph-uri=' + encodeURIComponent(this.defaultGraphs()[i]) + '&';
+ for (i = 0; i < this.namedGraphs().length; i++) urlQueryString += 'named-graph-uri=' + encodeURIComponent(this.namedGraphs()[i]) + '&';
+
+ // specify JSON output (currently output= supported by latest Joseki) (or other output)
+ urlQueryString += 'output=' + _output + '&';
+ return urlQueryString + 'query=' + encodeURIComponent(this.queryString());
+ }
+
+ /**
+ * Returns the HTTP GET URL to invoke this query. (Note that this returns a full HTTP GET URL
+ * even if this query is set to actually use POST.)
+ */
+ this.queryUrl = function() {
+ var url = this.service().endpoint() + '?';
+ return url + this.queryParameters();
+ };
+
+ //---------
+ // mutators
+ function _add_graphs(toAdd, arr) {
+ if (toAdd instanceof Array)
+ for (var i = 0; i < toAdd.length; i++) arr.push(toAdd[i]);
+ else
+ arr.push(toAdd);
+ }
+ this.addDefaultGraph = function(g) { _add_graphs(g, this.defaultGraphs()); };
+ this.addNamedGraph = function(g) { _add_graphs(g, this.namedGraphs()); };
+ this.setPrefix = function(p, u) { this.prefixes()[p] = u; };
+ this.setMethod = function(m) {
+ if (m != 'GET' && m != 'POST') throw("HTTP methods other than GET and POST are not supported.");
+ _method = m;
+ };
+ this.setRequestHeader = function(h, v) { _request_headers[h] = v; };
+
+ //---------------
+ // public methods
+
+ // use our varied transformations to create the various methods of actually issuing
+ // queries
+ for (var query_form in SPARQL._query_transformations) {
+ // need the extra function to properly scope query_form (qf)
+ this[query_form] = (function(qf) {
+ return function(queryString, callback) {
+ this._doQuery(queryString, callback, SPARQL._query_transformations[qf]);
+ };
+ })(query_form);
+ }
+
+
+ //------------
+ // constructor
+
+ return this;
+}
+
+// Nothing to see here, yet.
+SPARQL.QueryUtilities = {
+};
+
http://git-wip-us.apache.org/repos/asf/incubator-marmotta/blob/5fd590b4/extras/webjars/snorql/src/main/resources/style.css
----------------------------------------------------------------------
diff --git a/extras/webjars/snorql/src/main/resources/style.css b/extras/webjars/snorql/src/main/resources/style.css
new file mode 100755
index 0000000..acc8746
--- /dev/null
+++ b/extras/webjars/snorql/src/main/resources/style.css
@@ -0,0 +1,85 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+.snorql {
+ background: none repeat scroll 0 0 #eeeeee;
+ font-family: sans-serif;
+ padding: 1em 1em 5em 1em;
+ border: 2px solid #000000;
+ border-radius: 5px;
+ margin: 2em auto 10em auto;
+}
+#footer_snorql { font-size: 60%; margin: 10px 0; text-align: center; }
+.subtitle { text-align: center; margin-top: 0; }
+form { margin: 0; }
+textarea { width: 100%; margin: 10px 0;border:1px solid #999; }
+.snorql pre#prefixestext { color: #555; margin: 10px 0; width: auto; color: inherit; background-color: inherit; border: 0; }
+img { border: none; }
+.section { margin: 15px 0 0; padding: 0; }
+.busy { color: #888; }
+.link { background: url("link.png") center right no-repeat; padding-right: 13px; }
+.queryresults { border-collapse: collapse; margin-top: 0.3em; border: 1px solid gray;}
+.queryresults td, .queryresults th { padding: 0.2em 0.4em; vertical-align: top; }
+.uri { white-space: nowrap; }
+.uri a, a.uri { text-decoration: none; }
+.unbound { color: #888; }
+.queryresults a small { font-size: 100%; }
+.queryresults small { font-size: 100%; color: #666; }
+.queryresults .property { white-space: nowrap; }
+#rdficon { float: right; margin: 0.6em 1em; }
+.directory li { margin-bottom: 0.5em; }
+.directory small { font-size: 80%; color: #666; }
+
+.snorql h2 {
+ color: #666666;
+ margin: 0;
+ padding: 0;
+}
+.result h2 {
+ margin: 5px 0;
+ color: #666666;
+}
+/* .snorql #snorql_header, .snorql .section { background: #ccf; } */
+.snorql table.queryresults th { background: #666666; color: #ffffff; font-weight: bold; }
+.snorql table.queryresults tr.odd td { background-color: #aaaaaa !important; }
+.snorql table.queryresults tr.even td { background-color: #cccccc !important; }
+
+.browser h1, .browser h2 { color: #666666; }
+.browser #header, .browser .section { background: #666666; }
+.browser table.queryresults th { background: none repeat scroll 0 0 gray; color: white; }
+.browser table.queryresults tr.odd td { background-color: #aaaaaa !important; }
+.browser table.queryresults tr.even td { background-color: #cccccc !important; }
+
+#result {
+ border: 1px solid #999;
+ font-size: 12px;
+ overflow-x: auto;
+ padding: 5px;
+ width: 98%;
+ display:none;
+ background-color: white;
+}
+
+.snorql div.CodeMirror-scroll {
+ height: auto !important;
+ overflow-y: hidden !important;
+ overflow-x: auto !important;
+}
+
+.snorql div.CodeMirror-gutter pre, .snorql div.CodeMirror-lines pre {
+ overflow: inherit !important;
+}
http://git-wip-us.apache.org/repos/asf/incubator-marmotta/blob/5fd590b4/extras/webjars/snorql/src/main/resources/xml-to-html.xsl
----------------------------------------------------------------------
diff --git a/extras/webjars/snorql/src/main/resources/xml-to-html.xsl b/extras/webjars/snorql/src/main/resources/xml-to-html.xsl
new file mode 100755
index 0000000..1333027
--- /dev/null
+++ b/extras/webjars/snorql/src/main/resources/xml-to-html.xsl
@@ -0,0 +1,183 @@
+<?xml version="1.0"?>
+
+<!--
+
+XSLT script to format SPARQL Query Results XML Format into xhtml
+
+Copyright © 2004, 2005 World Wide Web Consortium, (Massachusetts
+Institute of Technology, European Research Consortium for
+Informatics and Mathematics, Keio University). All Rights
+Reserved. This work is distributed under the W3C® Software
+License [1] in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.
+
+[1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+
+Version 1 : Dave Beckett (DAWG)
+Version 2 : Jeen Broekstra (DAWG)
+Customization for SPARQler: Andy Seaborne
+
+-->
+
+<xsl:stylesheet version="1.0"
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+ xmlns="http://www.w3.org/1999/xhtml"
+ xmlns:res="http://www.w3.org/2005/sparql-results#"
+ exclude-result-prefixes="res xsl">
+
+ <!--
+ <xsl:output
+ method="html"
+ media-type="text/html"
+ doctype-public="-//W3C//DTD HTML 4.01 Transitional//EN"
+ indent="yes"
+ encoding="UTF-8"/>
+ -->
+
+ <!-- or this? -->
+
+ <xsl:output
+ method="xml"
+ indent="yes"
+ encoding="UTF-8"
+ doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
+ doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
+ omit-xml-declaration="no" />
+
+
+ <xsl:template name="header">
+ <div>
+ <h2>Header</h2>
+ <xsl:for-each select="res:head/res:link">
+ <p>Link to <xsl:value-of select="@href"/></p>
+ </xsl:for-each>
+ </div>
+ </xsl:template>
+
+ <xsl:template name="boolean-result">
+ <div>
+ <!--
+ <h2>Boolean Result</h2>
+ -->
+ <p>ASK => <xsl:value-of select="res:boolean"/></p>
+ </div>
+ </xsl:template>
+
+
+ <xsl:template name="vb-result">
+ <div>
+ <!--
+ <h2>Variable Bindings Result</h2>
+ <p>Ordered: <xsl:value-of select="res:results/@ordered"/></p>
+ <p>Distinct: <xsl:value-of select="res:results/@distinct"/></p>
+ -->
+
+ <table>
+ <xsl:text>
+ </xsl:text>
+ <tr>
+ <xsl:for-each select="res:head/res:variable">
+ <th><xsl:value-of select="@name"/></th>
+ </xsl:for-each>
+ </tr>
+ <xsl:text>
+ </xsl:text>
+ <xsl:for-each select="res:results/res:result">
+ <tr>
+ <xsl:apply-templates select="."/>
+ </tr>
+ </xsl:for-each>
+ </table>
+ </div>
+ </xsl:template>
+
+ <xsl:template match="res:result">
+ <xsl:variable name="current" select="."/>
+ <xsl:for-each select="//res:head/res:variable">
+ <xsl:variable name="name" select="@name"/>
+ <td>
+ <xsl:choose>
+ <xsl:when test="$current/res:binding[@name=$name]">
+ <!-- apply template for the correct value type (bnode, uri, literal) -->
+ <xsl:apply-templates select="$current/res:binding[@name=$name]"/>
+ </xsl:when>
+ <xsl:otherwise>
+ <!-- no binding available for this variable in this solution -->
+ </xsl:otherwise>
+ </xsl:choose>
+ </td>
+ </xsl:for-each>
+ </xsl:template>
+
+ <xsl:template match="res:bnode">
+ <xsl:text>_:</xsl:text>
+ <xsl:value-of select="text()"/>
+ </xsl:template>
+
+ <xsl:template match="res:uri">
+ <xsl:variable name="uri" select="text()"/>
+ <xsl:text><</xsl:text>
+ <xsl:value-of select="$uri"/>
+ <xsl:text>></xsl:text>
+ </xsl:template>
+
+ <xsl:template match="res:literal">
+ <xsl:text>"</xsl:text>
+ <xsl:value-of select="text()"/>
+ <xsl:text>"</xsl:text>
+
+ <xsl:choose>
+ <xsl:when test="@datatype">
+ <!-- datatyped literal value -->
+ ^^<<xsl:value-of select="@datatype"/>>
+ </xsl:when>
+ <xsl:when test="@xml:lang">
+ <!-- lang-string -->
+ @<xsl:value-of select="@xml:lang"/>
+ </xsl:when>
+ </xsl:choose>
+ </xsl:template>
+
+ <xsl:template match="res:sparql">
+ <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+ <head>
+ <title>SPARQL Query Results</title>
+ <style>
+ <![CDATA[
+ h1 { font-size: 150% ; }
+ h2 { font-size: 125% ; }
+ table { border-collapse: collapse ; border: 1px solid black ; }
+ td, th
+ { border: 1px solid black ;
+ padding-left:0.5em; padding-right: 0.5em;
+ padding-top:0.2ex ; padding-bottom:0.2ex
+ }
+ ]]>
+ </style>
+ </head>
+ <body>
+
+
+ <h1>SPARQL Query Results</h1>
+
+ <xsl:if test="res:head/res:link">
+ <xsl:call-template name="header"/>
+ </xsl:if>
+
+ <xsl:choose>
+ <xsl:when test="res:boolean">
+ <xsl:call-template name="boolean-result" />
+ </xsl:when>
+
+ <xsl:when test="res:results">
+ <xsl:call-template name="vb-result" />
+ </xsl:when>
+
+ </xsl:choose>
+
+
+ </body>
+ </html>
+ </xsl:template>
+</xsl:stylesheet>
http://git-wip-us.apache.org/repos/asf/incubator-marmotta/blob/5fd590b4/parent/pom.xml
----------------------------------------------------------------------
diff --git a/parent/pom.xml b/parent/pom.xml
index d8b89a8..f6ef3f8 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -905,6 +905,26 @@
<version>1.8.2</version>
</dependency>
<dependency>
+ <groupId>org.webjars</groupId>
+ <artifactId>jquery-ui</artifactId>
+ <version>1.8.21</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.marmotta.webjars</groupId>
+ <artifactId>codemirror</artifactId>
+ <version>2.24</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.marmotta.webjars</groupId>
+ <artifactId>snorql</artifactId>
+ <version>1.0</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.marmotta.webjars</groupId>
+ <artifactId>sgvizler</artifactId>
+ <version>0.5.1</version>
+ </dependency>
+ <dependency>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-client-js</artifactId>
<version>${project.version}</version>
http://git-wip-us.apache.org/repos/asf/incubator-marmotta/blob/5fd590b4/platform/marmotta-core/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-core/pom.xml b/platform/marmotta-core/pom.xml
index 6f4c57c..aceb0fa 100644
--- a/platform/marmotta-core/pom.xml
+++ b/platform/marmotta-core/pom.xml
@@ -311,6 +311,10 @@
<artifactId>jquery</artifactId>
</dependency>
<dependency>
+ <groupId>org.apache.marmotta.webjars</groupId>
+ <artifactId>sgvizler</artifactId>
+ </dependency>
+ <dependency>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-client-js</artifactId>
</dependency>
http://git-wip-us.apache.org/repos/asf/incubator-marmotta/blob/5fd590b4/platform/marmotta-core/src/main/resources/web/admin/configuration.html
----------------------------------------------------------------------
diff --git a/platform/marmotta-core/src/main/resources/web/admin/configuration.html b/platform/marmotta-core/src/main/resources/web/admin/configuration.html
index 928a336..63dc95c 100644
--- a/platform/marmotta-core/src/main/resources/web/admin/configuration.html
+++ b/platform/marmotta-core/src/main/resources/web/admin/configuration.html
@@ -22,7 +22,7 @@
<!--###BEGIN_HEAD###-->
<title>Core Module Configuration</title>
<link type="text/css" rel="stylesheet" href="../public/js/widgets/configurator/style.css">
- <script type="text/javascript" src="../public/js/lib/jquery-1.7.2.js"></script>
+ <script type="text/javascript" src="../../webjars/jquery/1.8.2/jquery.min.js"></script>
<script type="text/javascript" src="../public/js/widgets/configurator/configurator.js"></script>
<script type="text/javascript" src="js/widgets/database.js"></script>
<script type="text/javascript">
http://git-wip-us.apache.org/repos/asf/incubator-marmotta/blob/5fd590b4/platform/marmotta-core/src/main/resources/web/admin/dataview.html
----------------------------------------------------------------------
diff --git a/platform/marmotta-core/src/main/resources/web/admin/dataview.html b/platform/marmotta-core/src/main/resources/web/admin/dataview.html
index eec7574..850534f 100644
--- a/platform/marmotta-core/src/main/resources/web/admin/dataview.html
+++ b/platform/marmotta-core/src/main/resources/web/admin/dataview.html
@@ -23,9 +23,9 @@
<!--###BEGIN_HEAD###-->
<title>Data Views</title>
<meta charset="UTF-8"/>
- <script type="text/javascript" src="../public/js/lib/jquery-1.6.4.js"></script>
+ <script type="text/javascript" src="../../webjars/jquery/1.8.2/jquery.min.js"></script>
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
- <script type="text/javascript" src="js/lib/sgvizler.pack.js"></script>
+ <script type="text/javascript" src="../../webjars/sgvizler/0.5.1/sgvizler.js" id="sgvzlr_script" ></script>
<script type="text/javascript">
var HAS_DATA = true;
@@ -36,7 +36,7 @@
'blue','red','orange','green','navy','Crimson','DarkGreen','DarkTurquoise','DodgerBlue','OliveDrab','pink','violet',
'GoldenRod','Fuchsia','Darkorange','DarkSlateBlue','GreenYellow','LightSeaGreen','Maroon','MediumVioletRed']
- sgvizler.option.libfolder = "js/lib/";
+ sgvizler.option.libfolder = "../../webjars/sgvizler/0.5.1/lib";
sgvizler.option.stylepath = _SERVER_URL + _CURRENT_STYLE;
@@ -237,7 +237,7 @@
drawGraphs();
drawClasses();
}
- });
+ });
</script>
<style type="text/css">
http://git-wip-us.apache.org/repos/asf/incubator-marmotta/blob/5fd590b4/platform/marmotta-core/src/main/resources/web/admin/export.html
----------------------------------------------------------------------
diff --git a/platform/marmotta-core/src/main/resources/web/admin/export.html b/platform/marmotta-core/src/main/resources/web/admin/export.html
index cb9f40d..295fa56 100644
--- a/platform/marmotta-core/src/main/resources/web/admin/export.html
+++ b/platform/marmotta-core/src/main/resources/web/admin/export.html
@@ -21,7 +21,7 @@
<head>
<!--###BEGIN_HEAD###-->
<title>Exporter</title>
- <script type="text/javascript" src="../public/js/lib/jquery-1.7.2.js"></script>
+ <script type="text/javascript" src="../../webjars/jquery/1.8.2/jquery.min.js"></script>
<script type="text/javascript">
var updateDownloadLink = function() {