suzanne.soy/zotero
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #103 from aurimasv/tabulator

Browse Source 
Tabulator v0.8 RDF Parser
This commit is contained in:
Simon Kornblith 2012-05-05 12:35:24 -07:00
commit 6e3dfc45ee
12 changed files with 3157 additions and 3120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
chrome/content/zotero/xpcom/rdf.js
View File

@ -1,6 +0,0 @@
// Tweaks to get the Tabulator RDF library to work without Tabulator. All of this happens in the
// Zotero.RDF.AJAW namespace.
var kb = new RDFIndexedFormula();
var tabulator = {log:{debug:function(arg) {
Zotero.debug(arg, 4);
}}};

321
chrome/content/zotero/xpcom/rdf/identity.js
View File

@ -1,6 +1,6 @@
// Identity management and indexing for RDF // Identity management and indexing for RDF
// //
// This file provides RDFIndexedFormula a formula (set of triples) which // This file provides IndexedFormula a formula (set of triples) which
// indexed by predicate, subject and object. // indexed by predicate, subject and object.
// //
// It "smushes" (merges into a single node) things which are identical // It "smushes" (merges into a single node) things which are identical
@ -12,41 +12,25 @@
// 2007 Changed so as not to munge statements from documents when smushing // 2007 Changed so as not to munge statements from documents when smushing
// //
// //
/*jsl:option explicit*/
// Turn on JavaScriptLint variable declaration checking
$rdf.IndexedFormula = function () {
/*jsl:option explicit*/ // Turn on JavaScriptLint variable declaration checking var owl_ns = "http://www.w3.org/2002/07/owl#";
// var link_ns = "http://www.w3.org/2007/ont/link#";
owl_ns = "http://www.w3.org/2002/07/owl#";
link_ns = "http://www.w3.org/2006/link#";
/* hashString functions are used as array indeces. This is done to avoid /* hashString functions are used as array indeces. This is done to avoid
** conflict with existing properties of arrays such as length and map. ** conflict with existing properties of arrays such as length and map.
** See issue 139. ** See issue 139.
*/ */
RDFLiteral.prototype.hashString = RDFLiteral.prototype.toNT; $rdf.Literal.prototype.hashString = $rdf.Literal.prototype.toNT;
RDFSymbol.prototype.hashString = RDFSymbol.prototype.toNT; $rdf.Symbol.prototype.hashString = $rdf.Symbol.prototype.toNT;
RDFBlankNode.prototype.hashString = RDFBlankNode.prototype.toNT; $rdf.BlankNode.prototype.hashString = $rdf.BlankNode.prototype.toNT;
RDFCollection.prototype.hashString = RDFCollection.prototype.toNT; $rdf.Collection.prototype.hashString = $rdf.Collection.prototype.toNT;
RDFIndexedFormula.prototype = new RDFFormula();
RDFIndexedFormula.prototype.constructor = RDFIndexedFormula;
// RDFIndexedFormula.superclass = RDFFormula.prototype;
RDFIndexedFormula.SuperClass = RDFFormula;
RDFArrayRemove = function(a, x) { //removes all elements equal to x from a
for(var i=0; i<a.length; i++) {
if (a[i] == x) {
a.splice(i,1);
return;
}
}
throw "RDFArrayRemove: Array did not contain " + x;
};
//Stores an associative array that maps URIs to functions //Stores an associative array that maps URIs to functions
function RDFIndexedFormula(features) { $rdf.IndexedFormula = function (features) {
this.statements = []; // As in RDFFormula this.statements = []; // As in Formula
this.optional = []; this.optional = [];
this.propertyActions = []; // Array of functions to call when getting statement with {s X o} this.propertyActions = []; // Array of functions to call when getting statement with {s X o}
//maps <uri> to [f(F,s,p,o),...] //maps <uri> to [f(F,s,p,o),...]
@ -60,12 +44,10 @@ function RDFIndexedFormula(features) {
this.whyIndex = []; // Array of statements with X as provenance this.whyIndex = []; // Array of statements with X as provenance
this.index = [this.subjectIndex, this.predicateIndex, this.objectIndex, this.whyIndex]; this.index = [this.subjectIndex, this.predicateIndex, this.objectIndex, this.whyIndex];
this.namespaces = {} // Dictionary of namespace prefixes this.namespaces = {} // Dictionary of namespace prefixes
if (features == undefined) features = ["sameAs", if(features === undefined) features = ["sameAs",
"InverseFunctionalProperty", "FunctionalProperty"]; "InverseFunctionalProperty", "FunctionalProperty"];
// this.features = features // this.features = features
// Callbackify? // Callbackify?
function handleRDFType(formula, subj, pred, obj, why) { function handleRDFType(formula, subj, pred, obj, why) {
if(formula.typeCallback != undefined) if(formula.typeCallback != undefined)
formula.typeCallback(formula, obj, why); formula.typeCallback(formula, obj, why);
@ -79,90 +61,66 @@ function RDFIndexedFormula(features) {
} }
return done; // statement given is not needed if true return done; // statement given is not needed if true
} //handleRDFType } //handleRDFType
//If the predicate is #type, use handleRDFType to create a typeCallback on the object //If the predicate is #type, use handleRDFType to create a typeCallback on the object
this.propertyActions[ this.propertyActions['<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>'] = [handleRDFType];
'<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>'] = [ handleRDFType ];
// Assumption: these terms are not redirected @@fixme // Assumption: these terms are not redirected @@fixme
if (features.indexOf("sameAs") >=0) if($rdf.Util.ArrayIndexOf(features, "sameAs") >= 0)
this.propertyActions['<http://www.w3.org/2002/07/owl#sameAs>'] = [ this.propertyActions['<http://www.w3.org/2002/07/owl#sameAs>'] = [
function (formula, subj, pred, obj, why) { function (formula, subj, pred, obj, why) {
// tabulator.log.warn("Equating "+subj.uri+" sameAs "+obj.uri); //@@
formula.equate(subj, obj); formula.equate(subj, obj);
return true; // true if statement given is NOT needed in the store return true; // true if statement given is NOT needed in the store
}]; //sameAs -> equate & don't add to index }]; //sameAs -> equate & don't add to index
/* if($rdf.Util.ArrayIndexOf(features, "InverseFunctionalProperty") >= 0)
function newPropertyAction(formula, pred, action) {
tabulator.log.debug("newPropertyAction: "+pred);
if (formula.propertyActions[pred] == undefined)
formula.propertyActions[pred] = [];
formula.propertyActions[pred].push(action);
// Now apply the function to to statements already in the store
var toBeFixed = formula.statementsMatching(undefined, pred, undefined);
var i;
for (i=0; i<toBeFixed.length; i++) { // NOT optimized - sort toBeFixed etc
if (action(formula, toBeFixed[i].subject, pred, toBeFixed[i].object)) {
tabulator.log.debug("newPropertyAction: NOT removing "+toBeFixed[i]);
}
}
return false;
}
*/
if (features.indexOf("InverseFunctionalProperty") >= 0)
this.classActions["<" + owl_ns + "InverseFunctionalProperty>"] = [ this.classActions["<" + owl_ns + "InverseFunctionalProperty>"] = [
function (formula, subj, pred, obj, addFn) { function (formula, subj, pred, obj, addFn) {
return formula.newPropertyAction(subj, handle_IFP); // yes subj not pred! return formula.newPropertyAction(subj, handle_IFP); // yes subj not pred!
}]; //IFP -> handle_IFP, do add to index }]; //IFP -> handle_IFP, do add to index
if($rdf.Util.ArrayIndexOf(features, "FunctionalProperty") >= 0)
if (features.indexOf("FunctionalProperty") >= 0)
this.classActions["<" + owl_ns + "FunctionalProperty>"] = [ this.classActions["<" + owl_ns + "FunctionalProperty>"] = [
function (formula, subj, proj, obj, addFn) { function (formula, subj, proj, obj, addFn) {
return formula.newPropertyAction(subj, handle_FP); return formula.newPropertyAction(subj, handle_FP);
}]; //FP => handleFP, do add to index }
]; //FP => handleFP, do add to index
function handle_IFP(formula, subj, pred, obj) { function handle_IFP(formula, subj, pred, obj) {
var s1 = formula.any(undefined, pred, obj); var s1 = formula.any(undefined, pred, obj);
if(s1 == undefined) return false; // First time with this value if(s1 == undefined) return false; // First time with this value
// tabulator.log.warn("Equating "+s1.uri+" and "+subj.uri + " because IFP "+pred.uri); //@@
formula.equate(s1, subj); formula.equate(s1, subj);
return true; return true;
} //handle_IFP } //handle_IFP
function handle_FP(formula, subj, pred, obj) { function handle_FP(formula, subj, pred, obj) {
var o1 = formula.any(subj, pred, undefined); var o1 = formula.any(subj, pred, undefined);
if(o1 == undefined) return false; // First time with this value if(o1 == undefined) return false; // First time with this value
// tabulator.log.warn("Equating "+o1.uri+" and "+obj.uri + " because FP "+pred.uri); //@@
formula.equate(o1, obj); formula.equate(o1, obj);
return true; return true;
} //handle_FP } //handle_FP
} /* end IndexedFormula */
} /* end RDFIndexedFormula */ $rdf.IndexedFormula.prototype = new $rdf.Formula();
$rdf.IndexedFormula.prototype.constructor = $rdf.IndexedFormula;
$rdf.IndexedFormula.SuperClass = $rdf.Formula;
$rdf.IndexedFormula.prototype.newPropertyAction = function newPropertyAction(pred, action) {
//$rdf.log.debug("newPropertyAction: "+pred);
RDFIndexedFormula.prototype.newPropertyAction = function newPropertyAction(pred, action) {
tabulator.log.debug("newPropertyAction: "+pred);
var hash = pred.hashString(); var hash = pred.hashString();
if(this.propertyActions[hash] == undefined) if(this.propertyActions[hash] == undefined)
this.propertyActions[hash] = []; this.propertyActions[hash] = [];
this.propertyActions[hash].push(action); this.propertyActions[hash].push(action);
// Now apply the function to to statements already in the store // Now apply the function to to statements already in the store
var toBeFixed = this.statementsMatching(undefined, pred, undefined); var toBeFixed = this.statementsMatching(undefined, pred, undefined);
done = false; var done = false;
for(var i = 0; i < toBeFixed.length; i++) { // NOT optimized - sort toBeFixed etc for(var i = 0; i < toBeFixed.length; i++) { // NOT optimized - sort toBeFixed etc
done = done || action(this, toBeFixed[i].subject, pred, toBeFixed[i].object); done = done || action(this, toBeFixed[i].subject, pred, toBeFixed[i].object);
} }
return done; return done;
} }
$rdf.IndexedFormula.prototype.setPrefixForURI = function (prefix, nsuri) {
RDFPlainFormula = function() { return RDFIndexedFormula([]); } // No features
RDFIndexedFormula.prototype.setPrefixForURI = function(prefix, nsuri) {
//TODO:This is a hack for our own issues, which ought to be fixed post-release //TODO:This is a hack for our own issues, which ought to be fixed post-release
//See http://dig.csail.mit.edu/cgi-bin/roundup.cgi/tabulator/issue227 //See http://dig.csail.mit.edu/cgi-bin/roundup.cgi/$rdf/issue227
if(prefix == "tab" && this.namespaces["tab"]) { if(prefix == "tab" && this.namespaces["tab"]) {
return; return;
} }
@ -170,19 +128,22 @@ RDFIndexedFormula.prototype.setPrefixForURI = function(prefix, nsuri) {
} }
// Deprocated ... name too generic // Deprocated ... name too generic
RDFIndexedFormula.prototype.register = function(prefix, nsuri) { $rdf.IndexedFormula.prototype.register = function (prefix, nsuri) {
this.namespaces[prefix] = nsuri this.namespaces[prefix] = nsuri
} }
/** simplify graph in store when we realize two identifiers are equal /** simplify graph in store when we realize two identifiers are equivalent
We replace the bigger with the smaller. We replace the bigger with the smaller.
*/ */
RDFIndexedFormula.prototype.equate = function(u1, u2) { $rdf.IndexedFormula.prototype.equate = function (u1, u2) {
tabulator.log.debug("Equating "+u1+" and "+u2) // tabulator.log.warn("Equating "+u1+" and "+u2); // @@
//@@JAMBO Must canonicalize the uris to prevent errors from a=b=c
//03-21-2010
u1 = this.canon(u1);
u2 = this.canon(u2);
var d = u1.compareTerm(u2); var d = u1.compareTerm(u2);
if(!d) return true; // No information in {a = a} if(!d) return true; // No information in {a = a}
var big, small; var big, small;
@ -195,8 +156,8 @@ RDFIndexedFormula.prototype.equate = function(u1, u2) {
// Replace big with small, obsoleted with obsoleting. // Replace big with small, obsoleted with obsoleting.
// //
RDFIndexedFormula.prototype.replaceWith = function(big, small) { $rdf.IndexedFormula.prototype.replaceWith = function (big, small) {
tabulator.log.debug("Replacing "+big+" with "+small) // @@ //$rdf.log.debug("Replacing "+big+" with "+small) // @@
var oldhash = big.hashString(); var oldhash = big.hashString();
var newhash = small.hashString(); var newhash = small.hashString();
@ -205,7 +166,7 @@ RDFIndexedFormula.prototype.replaceWith = function(big, small) {
if(oldlist == undefined) return; // none to move if(oldlist == undefined) return; // none to move
var newlist = ix[newhash]; var newlist = ix[newhash];
if(newlist == undefined) { if(newlist == undefined) {
ix[newhash] = newlist; ix[newhash] = oldlist;
} else { } else {
ix[newhash] = oldlist.concat(newlist); ix[newhash] = oldlist.concat(newlist);
} }
@ -219,28 +180,34 @@ RDFIndexedFormula.prototype.replaceWith = function(big, small) {
this.redirections[oldhash] = small; this.redirections[oldhash] = small;
if(big.uri) { if(big.uri) {
//@@JAMBO: must update redirections,aliases from sub-items, too.
if(this.aliases[newhash] == undefined) if(this.aliases[newhash] == undefined)
this.aliases[newhash] = []; this.aliases[newhash] = [];
this.aliases[newhash].push(big); // Back link this.aliases[newhash].push(big); // Back link
if(this.aliases[oldhash]) {
for(var i = 0; i < this.aliases[oldhash].length; i++) {
this.redirections[this.aliases[oldhash][i].hashString()] = small;
this.aliases[newhash].push(this.aliases[oldhash][i]);
}
}
this.add(small, this.sym('http://www.w3.org/2006/link#uri'), big.uri) this.add(small, this.sym('http://www.w3.org/2007/ont/link#uri'), big.uri)
// If two things are equal, and one is requested, we should request the other. // If two things are equal, and one is requested, we should request the other.
if(this.sf) { if(this.sf) {
this.sf.nowKnownAs(big, small) this.sf.nowKnownAs(big, small)
} }
} }
moveIndex(this.classActions); moveIndex(this.classActions);
moveIndex(this.propertyActions); moveIndex(this.propertyActions);
tabulator.log.debug("Equate done. "+big+" to be known as "+small) //$rdf.log.debug("Equate done. "+big+" to be known as "+small)
return true; // true means the statement does not need to be put in return true; // true means the statement does not need to be put in
}; };
// Return the symbol with canonical URI as smushed // Return the symbol with canonical URI as smushed
RDFIndexedFormula.prototype.canon = function(term) { $rdf.IndexedFormula.prototype.canon = function (term) {
if(term == undefined) return term; if(term == undefined) return term;
var y = this.redirections[term.hashString()]; var y = this.redirections[term.hashString()];
if(y == undefined) return term; if(y == undefined) return term;
@ -248,7 +215,7 @@ RDFIndexedFormula.prototype.canon = function(term) {
} }
// Compare by canonical URI as smushed // Compare by canonical URI as smushed
RDFIndexedFormula.prototype.sameThings = function(x, y) { $rdf.IndexedFormula.prototype.sameThings = function (x, y) {
if(x.sameTerm(y)) return true; if(x.sameTerm(y)) return true;
var x1 = this.canon(x); var x1 = this.canon(x);
// alert('x1='+x1); // alert('x1='+x1);
@ -260,7 +227,7 @@ RDFIndexedFormula.prototype.sameThings = function(x, y) {
} }
// A list of all the URIs by which this thing is known // A list of all the URIs by which this thing is known
RDFIndexedFormula.prototype.uris = function(term) { $rdf.IndexedFormula.prototype.uris = function (term) {
var cterm = this.canon(term) var cterm = this.canon(term)
var terms = this.aliases[cterm.hashString()]; var terms = this.aliases[cterm.hashString()];
if(!cterm.uri) return [] if(!cterm.uri) return []
@ -278,14 +245,13 @@ RDFIndexedFormula.prototype.uris = function(term) {
function RDFMakeTerm(formula, val, canonicalize) { function RDFMakeTerm(formula, val, canonicalize) {
if(typeof val != 'object') { if(typeof val != 'object') {
if(typeof val == 'string') if(typeof val == 'string')
return new RDFLiteral(val); return new $rdf.Literal(val);
if(typeof val == 'number') if(typeof val == 'number')
return new RDFLiteral(val); // @@ differet types return new $rdf.Literal(val); // @@ differet types
if(typeof val == 'boolean') if(typeof val == 'boolean')
return new RDFLiteral(val?"1":"0", undefined, return new $rdf.Literal(val ? "1" : "0", undefined, $rdf.Symbol.prototype.XSDboolean);
RDFSymbol.prototype.XSDboolean);
else if(typeof val == 'number') else if(typeof val == 'number')
return new RDFLiteral(''+val); // @@ datatypes return new $rdf.Literal('' + val); // @@ datatypes
else if(typeof val == 'undefined') else if(typeof val == 'undefined')
return undefined; return undefined;
else // @@ add converting of dates and numbers else // @@ add converting of dates and numbers
@ -294,10 +260,14 @@ function RDFMakeTerm(formula,val, canonicalize) {
return val; return val;
} }
// add a triple to the store // Add a triple to the store
RDFIndexedFormula.prototype.add = function(subj, pred, obj, why) { //
// Returns the statement added
// (would it be better to return the original formula for chaining?)
//
$rdf.IndexedFormula.prototype.add = function (subj, pred, obj, why) {
var actions, st; var actions, st;
if (why == undefined) why = this.fetcher ? this.fetcher.appNode: kb.sym("chrome:theSession"); //system generated if(why == undefined) why = this.fetcher ? this.fetcher.appNode : this.sym("chrome:theSession"); //system generated
//defined in source.js, is this OK with identity.js only user? //defined in source.js, is this OK with identity.js only user?
subj = RDFMakeTerm(this, subj); subj = RDFMakeTerm(this, subj);
pred = RDFMakeTerm(this, pred); pred = RDFMakeTerm(this, pred);
@ -307,23 +277,7 @@ RDFIndexedFormula.prototype.add = function(subj, pred, obj, why) {
var hash = [this.canon(subj).hashString(), this.canon(pred).hashString(), var hash = [this.canon(subj).hashString(), this.canon(pred).hashString(),
this.canon(obj).hashString(), this.canon(why).hashString()]; this.canon(obj).hashString(), this.canon(why).hashString()];
/* // Removed TimBL 2007-01-06
// Check we don't already know it -- esp when working with dbview
// db view has many documents with the same triple - a waste.
// but is we want to be able to edit documents, we must maintain the original
// triples from each one. We might occasionally want to mutiple provences too
// for a full Truth Management System. Maybe this should be run-time option.
st = this.anyStatementMatching(subj,pred,obj) // @@@@@@@ temp fix <====WATCH OUT!
It is general necessary to know when data has come from >1 place.
Maybe this should be a mode?
*/
// This is wasting time and shouldn't happen at all
//st = this.anyStatementMatching(subj,pred,obj,why) // Avoid duplicates
//if (st != undefined) return; // already in store
// tabulator.log.debug("\nActions for "+s+" "+p+" "+o+". size="+this.statements.length)
if(this.predicateCallback != undefined) if(this.predicateCallback != undefined)
this.predicateCallback(this, pred, why); this.predicateCallback(this, pred, why);
@ -338,40 +292,39 @@ RDFIndexedFormula.prototype.add = function(subj, pred, obj, why) {
} }
//If we are tracking provenanance, every thing should be loaded into the store //If we are tracking provenanance, every thing should be loaded into the store
//if (done) return new RDFStatement(subj, pred, obj, why); // Don't put it in the store //if (done) return new Statement(subj, pred, obj, why); // Don't put it in the store
// still return this statement for owl:sameAs input // still return this statement for owl:sameAs input
var st = new RDFStatement(subj, pred, obj, why); var st = new $rdf.Statement(subj, pred, obj, why);
for(var i = 0; i < 4; i++) { for(var i = 0; i < 4; i++) {
var ix = this.index[i]; var ix = this.index[i];
var h = hash[i]; var h = hash[i];
if(ix[h] == undefined) ix[h] = []; if(ix[h] == undefined) ix[h] = [];
ix[h].push(st); // Set of things with this as subject ix[h].push(st); // Set of things with this as subject, etc
} }
tabulator.log.debug("ADDING {"+subj+" "+pred+" "+obj+"} "+why); //$rdf.log.debug("ADDING {"+subj+" "+pred+" "+obj+"} "+why);
this.statements.push(st); this.statements.push(st);
return st; return st;
}; //add }; //add
// Find out whether a given URI is used as symbol in the formula // Find out whether a given URI is used as symbol in the formula
RDFIndexedFormula.prototype.mentionsURI = function(uri) { $rdf.IndexedFormula.prototype.mentionsURI = function (uri) {
var hash = '<' + uri + '>'; var hash = '<' + uri + '>';
return (!!this.subjectIndex[hash] || !!this.objectIndex[hash] return (!!this.subjectIndex[hash]
|| !!this.objectIndex[hash]
|| !!this.predicateIndex[hash]); || !!this.predicateIndex[hash]);
} }
// Find an unused id for a file being edited: return a symbol // Find an unused id for a file being edited: return a symbol
// (Note: Slow iff a lot of them -- could be O(log(k)) ) // (Note: Slow iff a lot of them -- could be O(log(k)) )
RDFIndexedFormula.prototype.nextSymbol = function(doc) { $rdf.IndexedFormula.prototype.nextSymbol = function (doc) {
for(var i = 0;; i++) { for(var i = 0;; i++) {
var uri = doc.uri + '#n' + i; var uri = doc.uri + '#n' + i;
if (!this.mentionsURI(uri)) return kb.sym(uri); if(!this.mentionsURI(uri)) return this.sym(uri);
} }
} }
RDFIndexedFormula.prototype.anyStatementMatching = function(subj,pred,obj,why) { $rdf.IndexedFormula.prototype.anyStatementMatching = function (subj, pred, obj, why) {
var x = this.statementsMatching(subj, pred, obj, why, true); var x = this.statementsMatching(subj, pred, obj, why, true);
if(!x || x == []) return undefined; if(!x || x == []) return undefined;
return x[0]; return x[0];
@ -380,9 +333,8 @@ RDFIndexedFormula.prototype.anyStatementMatching = function(subj,pred,obj,why) {
// Return statements matching a pattern // Return statements matching a pattern
// ALL CONVENIENCE LOOKUP FUNCTIONS RELY ON THIS! // ALL CONVENIENCE LOOKUP FUNCTIONS RELY ON THIS!
RDFIndexedFormula.prototype.statementsMatching = function(subj,pred,obj,why,justOne) { $rdf.IndexedFormula.prototype.statementsMatching = function (subj, pred, obj, why, justOne) {
tabulator.log.debug("Matching {"+subj+" "+pred+" "+obj+"}"); //$rdf.log.debug("Matching {"+subj+" "+pred+" "+obj+"}");
var pat = [subj, pred, obj, why]; var pat = [subj, pred, obj, why];
var pattern = []; var pattern = [];
var hash = []; var hash = [];
@ -397,17 +349,22 @@ RDFIndexedFormula.prototype.statementsMatching = function(subj,pred,obj,why,just
hash[p] = pattern[p].hashString(); hash[p] = pattern[p].hashString();
} }
} }
if (given.length == 0) return this.statements; // Easy if(given.length == 0) {
return this.statements;
}
if(given.length == 1) { // Easy too, we have an index for that if(given.length == 1) { // Easy too, we have an index for that
var p = given[0]; var p = given[0];
var list = this.index[p][hash[p]]; var list = this.index[p][hash[p]];
if(list && justOne) {
if(list.length > 1)
list = list.slice(0, 1);
}
return list == undefined ? [] : list; return list == undefined ? [] : list;
} }
// Now given.length is 2, 3 or 4. // Now given.length is 2, 3 or 4.
// We hope that the scale-free nature of the data will mean we tend to get // We hope that the scale-free nature of the data will mean we tend to get
// a short index in there somewhere! // a short index in there somewhere!
var best = 1e10; // really bad var best = 1e10; // really bad
var best_i; var best_i;
for(var i = 0; i < given.length; i++) { for(var i = 0; i < given.length; i++) {
@ -437,29 +394,31 @@ RDFIndexedFormula.prototype.statementsMatching = function(subj,pred,obj,why,just
} }
if(st != null) results.push(st); if(st != null) results.push(st);
} }
if(justOne) {
if(results.length > 1)
results = results.slice(0, 1);
}
return results; return results;
}; // statementsMatching }; // statementsMatching
/** remove a particular statement from the bank **/ /** remove a particular statement from the bank **/
RDFIndexedFormula.prototype.remove = function (st) { $rdf.IndexedFormula.prototype.remove = function (st) {
tabulator.log.debug("entering remove w/ st=" + st); //$rdf.log.debug("entering remove w/ st=" + st);
var term = [st.subject, st.predicate, st.object, st.why]; var term = [st.subject, st.predicate, st.object, st.why];
for(var p = 0; p < 4; p++) { for(var p = 0; p < 4; p++) {
var c = this.canon(term[p]); var c = this.canon(term[p]);
var h = c.hashString(); var h = c.hashString();
if(this.index[p][h] == undefined) { if(this.index[p][h] == undefined) {
tabulator.log.warn ("Statement removal: no index '+p+': "+st); //$rdf.log.warn ("Statement removal: no index '+p+': "+st);
} else { } else {
RDFArrayRemove(this.index[p][h], st); $rdf.Util.RDFArrayRemove(this.index[p][h], st);
} }
} }
RDFArrayRemove(this.statements, st); $rdf.Util.RDFArrayRemove(this.statements, st);
}; //remove }; //remove
/** remove all statements matching args (within limit) **/ /** remove all statements matching args (within limit) **/
RDFIndexedFormula.prototype.removeMany = function (subj, pred, obj, why, limit) { $rdf.IndexedFormula.prototype.removeMany = function (subj, pred, obj, why, limit) {
tabulator.log.debug("entering removeMany w/ subj,pred,obj,why,limit = " + subj +", "+ pred+", " + obj+", " + why+", " + limit); //$rdf.log.debug("entering removeMany w/ subj,pred,obj,why,limit = " + subj +", "+ pred+", " + obj+", " + why+", " + limit);
var sts = this.statementsMatching(subj, pred, obj, why, false); var sts = this.statementsMatching(subj, pred, obj, why, false);
//This is a subtle bug that occcured in updateCenter.js too. //This is a subtle bug that occcured in updateCenter.js too.
//The fact is, this.statementsMatching returns this.whyIndex instead of a copy of it //The fact is, this.statementsMatching returns this.whyIndex instead of a copy of it
@ -468,56 +427,18 @@ RDFIndexedFormula.prototype.removeMany = function (subj, pred, obj, why, limit)
var statements = []; var statements = [];
for(var i = 0; i < sts.length; i++) statements.push(sts[i]); for(var i = 0; i < sts.length; i++) statements.push(sts[i]);
if(limit) statements = statements.slice(0, limit); if(limit) statements = statements.slice(0, limit);
for (var st in statements) this.remove(statements[st]); for(var i = 0; i < statements.length; i++) this.remove(statements[i]);
}; //removeMany }; //removeMany
/** Load a resorce into the store **/
RDFIndexedFormula.prototype.load = function(url) {
// get the XML
var xhr = Util.XMLHTTPFactory(); // returns a new XMLHttpRequest, or ActiveX XMLHTTP object
if (xhr.overrideMimeType) {
xhr.overrideMimeType("text/xml");
}
// Get privileges for cross-domain web access
if(!isExtension) {
try {
Util.enablePrivilege("UniversalXPConnect UniversalBrowserRead")
} catch(e) {
throw ("Failed to get privileges: (see http://dig.csail.mit.edu/2005/ajar/ajaw/Privileges.html)" + e)
}
}
xhr.open("GET", url, false); // Synchronous
xhr.send("");
// Get XML DOM Tree
var nodeTree = xhr.responseXML;
if (nodeTree === null && xhr.responseText !== null) {
// Only if the server fails to set Content-Type: text/xml AND xmlhttprequest doesn't have the overrideMimeType method
nodeTree = (new DOMParser()).parseFromString(xhr.responseText, 'text/xml');
}
// Get RDF statements fromm XML
// must be an XML document node tree
var parser = new RDFParser(this);
parser.parse(nodeTree,url);
}
/** Utility**/ /** Utility**/
/* @method: copyTo /* @method: copyTo
@discription: replace @template with @target and add appropriate triples (no triple removed) @description: replace @template with @target and add appropriate triples (no triple removed)
one-direction replication one-direction replication
*/ */
RDFIndexedFormula.prototype.copyTo = function(template,target,flags){ $rdf.IndexedFormula.prototype.copyTo = function (template, target, flags) {
if(!flags) flags = []; if(!flags) flags = [];
var statList = this.statementsMatching(template); var statList = this.statementsMatching(template);
if (flags.indexOf('two-direction')!=-1) if($rdf.Util.ArrayIndexOf(flags, 'two-direction') != -1)
statList.concat(this.statementsMatching(undefined, undefined, template)); statList.concat(this.statementsMatching(undefined, undefined, template));
for(var i = 0; i < statList.length; i++) { for(var i = 0; i < statList.length; i++) {
var st = statList[i]; var st = statList[i];
@ -530,64 +451,50 @@ RDFIndexedFormula.prototype.copyTo = function(template,target,flags){
case 'collection': case 'collection':
this.add(target, st.predicate, st.object.copy(this)); this.add(target, st.predicate, st.object.copy(this));
} }
if (flags.indexOf('delete')!=-1) this.remove(st); if($rdf.Util.ArrayIndexOf(flags, 'delete') != -1) this.remove(st);
} }
}; };
//for the case when you alter this.value (text modified in userinput.js) //for the case when you alter this.value (text modified in userinput.js)
RDFLiteral.prototype.copy = function(){ $rdf.Literal.prototype.copy = function () {
return new RDFLiteral(this.value,this.lang,this.datatype); return new $rdf.Literal(this.value, this.lang, this.datatype);
}; };
RDFBlankNode.prototype.copy = function(formula){ //depends on the formula $rdf.BlankNode.prototype.copy = function (formula) { //depends on the formula
var bnodeNew=new RDFBlankNode(); var bnodeNew = new $rdf.BlankNode();
formula.copyTo(this, bnodeNew); formula.copyTo(this, bnodeNew);
return bnodeNew; return bnodeNew;
} }
/** Full N3 bits -- placeholders only to allow parsing, no functionality! **/ /** Full N3 bits -- placeholders only to allow parsing, no functionality! **/
RDFIndexedFormula.prototype.newUniversal = function(uri) { $rdf.IndexedFormula.prototype.newUniversal = function (uri) {
var x = this.sym(uri); var x = this.sym(uri);
if(!this._universalVariables) this._universalVariables = []; if(!this._universalVariables) this._universalVariables = [];
this._universalVariables.push(x); this._universalVariables.push(x);
return x; return x;
} }
RDFIndexedFormula.prototype.newExistential = function(uri) { $rdf.IndexedFormula.prototype.newExistential = function (uri) {
if(!uri) return this.bnode(); if(!uri) return this.bnode();
var x = this.sym(uri); var x = this.sym(uri);
return this.declareExistential(x); return this.declareExistential(x);
} }
RDFIndexedFormula.prototype.declareExistential = function(x) { $rdf.IndexedFormula.prototype.declareExistential = function (x) {
if(!this._existentialVariables) this._existentialVariables = []; if(!this._existentialVariables) this._existentialVariables = [];
this._existentialVariables.push(x); this._existentialVariables.push(x);
return x; return x;
} }
RDFIndexedFormula.prototype.formula = function(features) { $rdf.IndexedFormula.prototype.formula = function (features) {
return new RDFIndexedFormula(features); return new $rdf.IndexedFormula(features);
} }
RDFIndexedFormula.prototype.close = function() { $rdf.IndexedFormula.prototype.close = function () {
return this; return this;
} }
RDFIndexedFormula.prototype.hashString = RDFIndexedFormula.prototype.toNT; $rdf.IndexedFormula.prototype.hashString = $rdf.IndexedFormula.prototype.toNT;
///////////////////////////// Provenance tracking
//
// Where did this statement come from?
//
/*
RDFStatement.prototype.original = function() {
for (var st = this;; st = st.why.premis[0]) {
if (st.why.termType && st.why.termType== 'symbol')
return this; // This statement came from a document
}
}
*/
return $rdf.IndexedFormula;
}();
// ends // ends

32
chrome/content/zotero/xpcom/rdf/init.js Normal file
View File

@ -0,0 +1,32 @@
/* Set up the environment before loading the rest of the files into Zotero */
Zotero.RDF.AJAW = {
Util: {
ArrayIndexOf: function (arr, item, i) {
//supported in all browsers except IE<9
return arr.indexOf(item, i);
},
RDFArrayRemove: function (a, x) { //removes all statements equal to x from a
for(var i = 0; i < a.length; i++) {
//TODO: This used to be the following, which didnt always work..why
//if(a[i] == x)
if(a[i].subject.sameTerm(x.subject)
&& a[i].predicate.sameTerm(x.predicate)
&& a[i].object.sameTerm(x.object)
&& a[i].why.sameTerm(x.why)) {
a.splice(i, 1);
return;
}
}
throw "RDFArrayRemove: Array did not contain " + x;
},
},
tabulator: {
log: {
debug: Zotero.debug,
warn: Zotero.debug
}
},
alert: Zotero.debug
};
Zotero.RDF.AJAW.$rdf = Zotero.RDF.AJAW;

150
chrome/content/zotero/xpcom/rdf/match.js
View File

@ -5,75 +5,41 @@
// //
// We retpresent a set as an associative array whose value for // We retpresent a set as an associative array whose value for
// each member is set to true. // each member is set to true.
$rdf.Symbol.prototype.sameTerm = function (other) {
/* Not used, bogus. See identity.js for the ones really used. if(!other) {
RDFFormula.prototype.statementsMatching = function(s,p,o,w) { return false
var results = []
var i
var ls = this.statements.length
for (i=0; i<ls; i++) {
var st = this.statements[i]
if (RDFTermMatch(p, st.predicate) && // first as simplest
RDFTermMatch(s, st.subject) &&
RDFTermMatch(o, st.object) &&
RDFTermMatch(w, st.why)) {
results[st] = true @@@@ sould use numeric indexed array
} }
}
return results
}
RDFFormula.prototype.anyStatementMatching = function(s,p,o,w) {
var ls = this.statements.length
var i
for (i=0; i<ls; i++) {
var st = this.statements[i]
if (RDFTermMatch(p, st.predicate) && // first as simplest
RDFTermMatch(s, st.subject) &&
RDFTermMatch(o, st.object) &&
RDFTermMatch(w, st.why)) {
return st
}
}
return undefined
}
*/
function RDFTermMatch(pattern, term) {
if (typeof pattern == 'undefined') return true;
return pattern.sameTerm(term)
}
RDFSymbol.prototype.sameTerm = function(other) {
if (!other) { return false }
return((this.termType == other.termType) && (this.uri == other.uri)) return((this.termType == other.termType) && (this.uri == other.uri))
} }
RDFBlankNode.prototype.sameTerm = function(other) { $rdf.BlankNode.prototype.sameTerm = function (other) {
if (!other) { return false } if(!other) {
return false
}
return((this.termType == other.termType) && (this.id == other.id)) return((this.termType == other.termType) && (this.id == other.id))
} }
RDFLiteral.prototype.sameTerm = function(other) { $rdf.Literal.prototype.sameTerm = function (other) {
if (!other) { return false } if(!other) {
return false
}
return((this.termType == other.termType) return((this.termType == other.termType)
&& (this.value == other.value) && (this.value == other.value)
&& (this.lang == other.lang) && && (this.lang == other.lang)
((!this.datatype && !other.datatype) && ((!this.datatype && !other.datatype)
|| this.datatype.sameTerm(other.datatype))) || (this.datatype && this.datatype.sameTerm(other.datatype))))
} }
RDFVariable.prototype.sameTerm = function (other) { $rdf.Variable.prototype.sameTerm = function (other) {
if (!other) { return false } if(!other) {
return false
}
return((this.termType == other.termType) && (this.uri == other.uri)) return((this.termType == other.termType) && (this.uri == other.uri))
} }
RDFCollection.prototype.sameTerm = RDFBlankNode.prototype.sameTerm $rdf.Collection.prototype.sameTerm = $rdf.BlankNode.prototype.sameTerm
RDFFormula.prototype.sameTerm = function (other) { $rdf.Formula.prototype.sameTerm = function (other) {
return this.hashString() == other.hashString(); return this.hashString() == other.hashString();
} }
// Comparison for ordering // Comparison for ordering
@ -84,19 +50,15 @@ RDFFormula.prototype.sameTerm = function (other) {
// When we smush nodes we take the lowest value. This is not // When we smush nodes we take the lowest value. This is not
// arbitrary: we want the value actually used to be the literal // arbitrary: we want the value actually used to be the literal
// (or list or formula). // (or list or formula).
$rdf.Literal.prototype.classOrder = 1
RDFLiteral.prototype.classOrder = 1 $rdf.Collection.prototype.classOrder = 3
// RDFList.prototype.classOrder = 2 $rdf.Formula.prototype.classOrder = 4
// RDFSet.prototype.classOrder = 3 $rdf.Symbol.prototype.classOrder = 5
RDFCollection.prototype.classOrder = 3 $rdf.BlankNode.prototype.classOrder = 6
RDFFormula.prototype.classOrder = 4
RDFSymbol.prototype.classOrder = 5
RDFBlankNode.prototype.classOrder = 6
// Compaisons return sign(self - other) // Compaisons return sign(self - other)
// Literals must come out before terms for smushing // Literals must come out before terms for smushing
$rdf.Literal.prototype.compareTerm = function (other) {
RDFLiteral.prototype.compareTerm = function(other) {
if(this.classOrder < other.classOrder) return -1 if(this.classOrder < other.classOrder) return -1
if(this.classOrder > other.classOrder) return +1 if(this.classOrder > other.classOrder) return +1
if(this.value < other.value) return -1 if(this.value < other.value) return -1
@ -104,7 +66,7 @@ RDFLiteral.prototype.compareTerm = function(other) {
return 0 return 0
} }
RDFSymbol.prototype.compareTerm = function(other) { $rdf.Symbol.prototype.compareTerm = function (other) {
if(this.classOrder < other.classOrder) return -1 if(this.classOrder < other.classOrder) return -1
if(this.classOrder > other.classOrder) return +1 if(this.classOrder > other.classOrder) return +1
if(this.uri < other.uri) return -1 if(this.uri < other.uri) return -1
@ -112,7 +74,7 @@ RDFSymbol.prototype.compareTerm = function(other) {
return 0 return 0
} }
RDFBlankNode.prototype.compareTerm = function(other) { $rdf.BlankNode.prototype.compareTerm = function (other) {
if(this.classOrder < other.classOrder) return -1 if(this.classOrder < other.classOrder) return -1
if(this.classOrder > other.classOrder) return +1 if(this.classOrder > other.classOrder) return +1
if(this.id < other.id) return -1 if(this.id < other.id) return -1
@ -120,28 +82,39 @@ RDFBlankNode.prototype.compareTerm = function(other) {
return 0 return 0
} }
RDFCollection.prototype.compareTerm = RDFBlankNode.prototype.compareTerm $rdf.Collection.prototype.compareTerm = $rdf.BlankNode.prototype.compareTerm
// Convenience routines // Convenience routines
// Only one of s p o can be undefined, and w is optional. // Only one of s p o can be undefined, and w is optional.
RDFFormula.prototype.each = function(s,p,o,w) { $rdf.Formula.prototype.each = function (s, p, o, w) {
var results = [] var results = []
var st, sts = this.statementsMatching(s,p,o,w) var st, sts = this.statementsMatching(s, p, o, w, false)
var i, n = sts.length var i, n = sts.length
if(typeof s == 'undefined') { if(typeof s == 'undefined') {
for (i=0; i<n; i++) {st=sts[i]; results.push(st.subject)} for(i = 0; i < n; i++) {
st = sts[i];
results.push(st.subject)
}
} else if(typeof p == 'undefined') { } else if(typeof p == 'undefined') {
for (i=0; i<n; i++) {st=sts[i]; results.push(st.predicate)} for(i = 0; i < n; i++) {
st = sts[i];
results.push(st.predicate)
}
} else if(typeof o == 'undefined') { } else if(typeof o == 'undefined') {
for (i=0; i<n; i++) {st=sts[i]; results.push(st.object)} for(i = 0; i < n; i++) {
st = sts[i];
results.push(st.object)
}
} else if(typeof w == 'undefined') { } else if(typeof w == 'undefined') {
for (i=0; i<n; i++) {st=sts[i]; results.push(st.why)} for(i = 0; i < n; i++) {
st = sts[i];
results.push(st.why)
}
} }
return results return results
} }
RDFFormula.prototype.any = function(s,p,o,w) { $rdf.Formula.prototype.any = function (s, p, o, w) {
var st = this.anyStatementMatching(s, p, o, w) var st = this.anyStatementMatching(s, p, o, w)
if(typeof st == 'undefined') return undefined; if(typeof st == 'undefined') return undefined;
@ -152,27 +125,20 @@ RDFFormula.prototype.any = function(s,p,o,w) {
return undefined return undefined
} }
RDFFormula.prototype.the = function(s,p,o,w) { $rdf.Formula.prototype.holds = function (s, p, o, w) {
var st = this.anyStatementMatching(s, p, o, w)
if(typeof st == 'undefined') return false;
return true;
}
$rdf.Formula.prototype.the = function (s, p, o, w) {
// the() should contain a check there is only one // the() should contain a check there is only one
var x = this.any(s, p, o, w) var x = this.any(s, p, o, w)
if(typeof x == 'undefined') if(typeof x == 'undefined')
tabulator.log.error("No value found for the(){" + s + " " + p + " " + o + "}.") $rdf.log.error("No value found for the(){" + s + " " + p + " " + o + "}.")
return x return x
} }
RDFFormula.prototype.whether = function(s,p,o,w) { $rdf.Formula.prototype.whether = function (s, p, o, w) {
return this.statementsMatching(s,p,o,w).length; return this.statementsMatching(s, p, o, w, false).length;
} }
// Not a method. For use in sorts
function RDFComparePredicateObject(self, other) {
var x = self.predicate.compareTerm(other.predicate)
if (x !=0) return x
return self.object.compareTerm(other.object)
}
function RDFComparePredicateSubject(self, other) {
var x = self.predicate.compareTerm(other.predicate)
if (x !=0) return x
return self.subject.compareTerm(other.subject)
}
// ends

285
chrome/content/zotero/xpcom/rdf/n3parser.js
View File

@ -1,33 +1,43 @@
// Things we need to define to make converted pythn code work in js $rdf.N3Parser = function () {
// environment of tabulator
function hexify(str) { // also used in parser
return encodeURI(str);
}
// Things we need to define to make converted pythn code work in js
// environment of $rdf
var RDFSink_forSomeSym = "http://www.w3.org/2000/10/swap/log#forSome"; var RDFSink_forSomeSym = "http://www.w3.org/2000/10/swap/log#forSome";
var RDFSink_forAllSym = "http://www.w3.org/2000/10/swap/log#forAll"; var RDFSink_forAllSym = "http://www.w3.org/2000/10/swap/log#forAll";
var Logic_NS = "http://www.w3.org/2000/10/swap/log#"; var Logic_NS = "http://www.w3.org/2000/10/swap/log#";
// pyjs seems to reference runtime library which I didn't find // pyjs seems to reference runtime library which I didn't find
var pyjslib_Tuple = function (theList) {
return theList
};
pyjslib_Tuple = function(theList) { return theList }; var pyjslib_List = function (theList) {
return theList
};
pyjslib_List = function(theList) { return theList }; var pyjslib_Dict = function (listOfPairs) {
pyjslib_Dict = function(listOfPairs) {
if(listOfPairs.length > 0) if(listOfPairs.length > 0)
throw "missing.js: oops nnonempty dict not imp"; throw "missing.js: oops nnonempty dict not imp";
return []; return [];
} }
pyjslib_len = function(s) { return s.length } var pyjslib_len = function (s) {
return s.length
}
pyjslib_slice = function(str, i, j) { var pyjslib_slice = function (str, i, j) {
if(typeof str.slice == 'undefined') if(typeof str.slice == 'undefined')
throw '@@ mising.js: No .slice function for ' + str + ' of type ' + (typeof str) throw '@@ mising.js: No .slice function for ' + str + ' of type ' + (typeof str)
if((typeof j == 'undefined') || (j == null)) return str.slice(i); if((typeof j == 'undefined') || (j == null)) return str.slice(i);
return str.slice(i, j) // @ exactly the same spec? return str.slice(i, j) // @ exactly the same spec?
} }
StopIteration = Error('dummy error stop iteration') var StopIteration = Error('dummy error stop iteration');
pyjslib_Iterator = function(theList) { var pyjslib_Iterator = function (theList) {
this.last = 0; this.last = 0;
this.li = theList; this.li = theList;
this.next = function () { this.next = function () {
@ -35,43 +45,42 @@ pyjslib_Iterator = function(theList) {
return this.li[this.last++]; return this.li[this.last++];
} }
return this; return this;
} };
ord = function(str) { var ord = function (str) {
return str.charCodeAt(0) return str.charCodeAt(0)
} }
string_find = function(str, s) { var string_find = function (str, s) {
return str.indexOf(s) return str.indexOf(s)
} }
assertFudge = function(condition, desc) { var assertFudge = function (condition, desc) {
if(condition) return; if(condition) return;
if(desc) throw "python Assertion failed: " + desc; if(desc) throw "python Assertion failed: " + desc;
throw "(python) Assertion failed."; throw "(python) Assertion failed.";
} }
stringFromCharCode = function(uesc) { var stringFromCharCode = function (uesc) {
return String.fromCharCode(uesc); return String.fromCharCode(uesc);
} }
var uripath_join = function (base, given) {
return $rdf.Util.uri.join(given, base) // sad but true
uripath_join = function(base, given) {
return Util.uri.join(given, base) // sad but true
} }
var becauseSubexpression = null; // No reason needed var becauseSubexpression = null; // No reason needed
var diag_tracking = 0; var diag_tracking = 0;
var diag_chatty_flag = 0; var diag_chatty_flag = 0;
diag_progress = function(str) { tabulator.log.debug(str); } var diag_progress = function (str) {
/*$rdf.log.debug(str);*/
}
// why_BecauseOfData = function(doc, reason) { return doc }; // why_BecauseOfData = function(doc, reason) { return doc };
var RDF_type_URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
RDF_type_URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"; var DAML_sameAs_URI = "http://www.w3.org/2002/07/owl#sameAs";
DAML_sameAs_URI = "http://www.w3.org/2002/07/owl#sameAs";
/* /*
function SyntaxError(details) { function SyntaxError(details) {
@ -132,9 +141,11 @@ var number_syntax = new RegExp("^([-+]?[0-9]+)(\\.[0-9]+)?(e[-+]?[0-9]+)?", 'g')
var digitstring = new RegExp("^[0-9]+", 'g'); var digitstring = new RegExp("^[0-9]+", 'g');
var interesting = new RegExp("[\\\\\\r\\n\\\"]", 'g'); var interesting = new RegExp("[\\\\\\r\\n\\\"]", 'g');
var langcode = new RegExp("^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)?", 'g'); var langcode = new RegExp("^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)?", 'g');
function SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) { function SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) {
return new __SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why); return new __SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why);
} }
function __SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) { function __SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) {
if(typeof openFormula == 'undefined') openFormula = null; if(typeof openFormula == 'undefined') openFormula = null;
if(typeof thisDoc == 'undefined') thisDoc = ""; if(typeof thisDoc == 'undefined') thisDoc = "";
@ -176,12 +187,10 @@ function __SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI,
} }
if(baseURI) { if(baseURI) {
this._baseURI = baseURI; this._baseURI = baseURI;
} } else {
else {
if(thisDoc) { if(thisDoc) {
this._baseURI = thisDoc; this._baseURI = thisDoc;
} } else {
else {
this._baseURI = null; this._baseURI = null;
} }
} }
@ -189,20 +198,17 @@ function __SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI,
if(!(this._genPrefix)) { if(!(this._genPrefix)) {
if(this._thisDoc) { if(this._thisDoc) {
this._genPrefix = (this._thisDoc + "#_g"); this._genPrefix = (this._thisDoc + "#_g");
} } else {
else {
this._genPrefix = RDFSink_uniqueURI(); this._genPrefix = RDFSink_uniqueURI();
} }
} }
if((openFormula == null)) { if((openFormula == null)) {
if(this._thisDoc) { if(this._thisDoc) {
this._formula = store.formula((thisDoc + "#_formula")); this._formula = store.formula((thisDoc + "#_formula"));
} } else {
else {
this._formula = store.formula(); this._formula = store.formula();
} }
} } else {
else {
this._formula = openFormula; this._formula = openFormula;
} }
this._context = this._formula; this._context = this._formula;
@ -267,21 +273,18 @@ __SinkParser.prototype.tok = function(tok, str, i) {
/* /*
Check for keyword. Space must have been stripped on entry and Check for keyword. Space must have been stripped on entry and
we must not be at end of file.*/ we must not be at end of file.*/
var whitespace = "\t\n\v\f\r "; var whitespace = "\t\n\v\f\r ";
if((pyjslib_slice(str, i, (i + 1)) == "@")) { if((pyjslib_slice(str, i, (i + 1)) == "@")) {
var i = (i + 1); var i = (i + 1);
} } else {
else { if(($rdf.Util.ArrayIndexOf(this.keywords, tok) < 0)) {
if ((this.keywords.indexOf(tok) < 0)) {
return -1; return -1;
} }
} }
var k = (i + pyjslib_len(tok)); var k = (i + pyjslib_len(tok));
if ((pyjslib_slice(str, i, k) == tok) && (_notQNameChars.indexOf(str[k]) >= 0)) { if((pyjslib_slice(str, i, k) == tok) && (_notQNameChars.indexOf(str.charAt(k)) >= 0)) {
return k; return k;
} } else {
else {
return -1; return -1;
} }
}; };
@ -320,7 +323,7 @@ __SinkParser.prototype.directive = function(str, i) {
var x = __x.next(); var x = __x.next();
if ((this._variables.indexOf(x) < 0) || (this._parentVariables.indexOf(x) >= 0)) { if($rdf.Util.ArrayIndexOf(this._variables, x) < 0 || ($rdf.Util.ArrayIndexOf(this._parentVariables, x) >= 0)) {
this._variables[x] = (this._context.newUniversal(x)); this._variables[x] = (this._context.newUniversal(x));
} }
@ -371,8 +374,7 @@ __SinkParser.prototype.directive = function(str, i) {
var ns = t[1].uri; var ns = t[1].uri;
if(this._baseURI) { if(this._baseURI) {
var ns = uripath_join(this._baseURI, ns); var ns = uripath_join(this._baseURI, ns);
} } else {
else {
assertFudge((ns.indexOf(":") >= 0), "With no base URI, cannot handle relative URI for NS"); assertFudge((ns.indexOf(":") >= 0), "With no base URI, cannot handle relative URI for NS");
} }
assertFudge((ns.indexOf(":") >= 0)); assertFudge((ns.indexOf(":") >= 0));
@ -391,8 +393,7 @@ __SinkParser.prototype.directive = function(str, i) {
var ns = t[0].uri; var ns = t[0].uri;
if(this._baseURI) { if(this._baseURI) {
var ns = uripath_join(this._baseURI, ns); var ns = uripath_join(this._baseURI, ns);
} } else {
else {
throw BadSyntax(this._thisDoc, this.lines, str, j, (("With no previous base URI, cannot use relative URI in @base <" + ns) + ">")); throw BadSyntax(this._thisDoc, this.lines, str, j, (("With no previous base URI, cannot use relative URI in @base <" + ns) + ">"));
} }
assertFudge((ns.indexOf(":") >= 0)); assertFudge((ns.indexOf(":") >= 0));
@ -403,8 +404,7 @@ __SinkParser.prototype.directive = function(str, i) {
}; };
__SinkParser.prototype.bind = function (qn, uri) { __SinkParser.prototype.bind = function (qn, uri) {
if((qn == "")) { if((qn == "")) {
} } else {
else {
this._store.setPrefixForURI(qn, uri); this._store.setPrefixForURI(qn, uri);
} }
}; };
@ -414,14 +414,12 @@ __SinkParser.prototype.setKeywords = function(k) {
if((k == null)) { if((k == null)) {
this.keywordsSet = 0; this.keywordsSet = 0;
} } else {
else {
this.keywords = k; this.keywords = k;
this.keywordsSet = 1; this.keywordsSet = 1;
} }
}; };
__SinkParser.prototype.startDoc = function() { __SinkParser.prototype.startDoc = function () {};
};
__SinkParser.prototype.endDoc = function () { __SinkParser.prototype.endDoc = function () {
/* /*
Signal end of document and stop parsing. returns formula*/ Signal end of document and stop parsing. returns formula*/
@ -557,8 +555,7 @@ __SinkParser.prototype.path = function(str, i, res) {
var pred = res.pop(); var pred = res.pop();
if((ch == "^")) { if((ch == "^")) {
this.makeStatement(new pyjslib_Tuple([this._context, pred, obj, subj])); this.makeStatement(new pyjslib_Tuple([this._context, pred, obj, subj]));
} } else {
else {
this.makeStatement(new pyjslib_Tuple([this._context, pred, subj, obj])); this.makeStatement(new pyjslib_Tuple([this._context, pred, subj, obj]));
} }
res.push(obj); res.push(obj);
@ -630,8 +627,7 @@ __SinkParser.prototype.node = function(str, i, res, subjectAlready) {
if((pyjslib_slice(str, j, (j + 1)) == ";")) { if((pyjslib_slice(str, j, (j + 1)) == ";")) {
var j = (j + 1); var j = (j + 1);
} }
} } else {
else {
throw BadSyntax(this._thisDoc, this.lines, str, i, "objectList expected after [= "); throw BadSyntax(this._thisDoc, this.lines, str, i, "objectList expected after [= ");
} }
} }
@ -671,12 +667,10 @@ __SinkParser.prototype.node = function(str, i, res, subjectAlready) {
if(!(first_run)) { if(!(first_run)) {
if((pyjslib_slice(str, i, (i + 1)) == ",")) { if((pyjslib_slice(str, i, (i + 1)) == ",")) {
i += 1; i += 1;
} } else {
else {
throw BadSyntax(this._thisDoc, this.lines, str, i, "expected: ','"); throw BadSyntax(this._thisDoc, this.lines, str, i, "expected: ','");
} }
} } else {
else {
var first_run = false; var first_run = false;
} }
var item = new pyjslib_List([]); var item = new pyjslib_List([]);
@ -688,8 +682,7 @@ __SinkParser.prototype.node = function(str, i, res, subjectAlready) {
} }
res.push(this._store.newSet(mylist, this._context)); res.push(this._store.newSet(mylist, this._context));
return j; return j;
} } else {
else {
var j = (i + 1); var j = (i + 1);
var oldParentContext = this._parentContext; var oldParentContext = this._parentContext;
this._parentContext = this._context; this._parentContext = this._context;
@ -825,8 +818,7 @@ __SinkParser.prototype.property_list = function(str, i, subj) {
var sym = pairFudge[1]; var sym = pairFudge[1];
if((dir == "->")) { if((dir == "->")) {
this.makeStatement(new pyjslib_Tuple([this._context, sym, subj, obj])); this.makeStatement(new pyjslib_Tuple([this._context, sym, subj, obj]));
} } else {
else {
this.makeStatement(new pyjslib_Tuple([this._context, sym, obj, subj])); this.makeStatement(new pyjslib_Tuple([this._context, sym, obj, subj]));
} }
@ -862,13 +854,12 @@ __SinkParser.prototype.commaSeparatedList = function(str, j, res, ofUris) {
throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF found expecting comma sep list"); throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF found expecting comma sep list");
return i; return i;
} }
if ((str[i] == ".")) { if((str.charAt(i) == ".")) {
return j; return j;
} }
if(ofUris) { if(ofUris) {
var i = this.uri_ref2(str, i, res); var i = this.uri_ref2(str, i, res);
} } else {
else {
var i = this.bareWord(str, i, res); var i = this.bareWord(str, i, res);
} }
if((i < 0)) { if((i < 0)) {
@ -888,8 +879,7 @@ __SinkParser.prototype.commaSeparatedList = function(str, j, res, ofUris) {
} }
if(ofUris) { if(ofUris) {
var i = this.uri_ref2(str, (j + 1), res); var i = this.uri_ref2(str, (j + 1), res);
} } else {
else {
var i = this.bareWord(str, (j + 1), res); var i = this.bareWord(str, (j + 1), res);
} }
if((i < 0)) { if((i < 0)) {
@ -953,8 +943,7 @@ __SinkParser.prototype.uri_ref2 = function(str, i, res) {
if((pfx == null)) { if((pfx == null)) {
assertFudge(0, "not used?"); assertFudge(0, "not used?");
var ns = (this._baseURI + ADDED_HASH); var ns = (this._baseURI + ADDED_HASH);
} } else {
else {
var ns = this._bindings[pfx]; var ns = this._bindings[pfx];
if(!(ns)) { if(!(ns)) {
if((pfx == "_")) { if((pfx == "_")) {
@ -965,10 +954,9 @@ __SinkParser.prototype.uri_ref2 = function(str, i, res) {
} }
} }
var symb = this._store.sym((ns + ln)); var symb = this._store.sym((ns + ln));
if ((this._variables.indexOf(symb) >= 0)) { if(($rdf.Util.ArrayIndexOf(this._variables, symb) >= 0)) {
res.push(this._variables[symb]); res.push(this._variables[symb]);
} } else {
else {
res.push(symb); res.push(symb);
} }
return j; return j;
@ -977,7 +965,7 @@ __SinkParser.prototype.uri_ref2 = function(str, i, res) {
if((i < 0)) { if((i < 0)) {
return -1; return -1;
} }
if ((str[i] == "?")) { if((str.charAt(i) == "?")) {
var v = new pyjslib_List([]); var v = new pyjslib_List([]);
var j = this.variable(str, i, v); var j = this.variable(str, i, v);
if((j > 0)) { if((j > 0)) {
@ -985,27 +973,24 @@ __SinkParser.prototype.uri_ref2 = function(str, i, res) {
return j; return j;
} }
return -1; return -1;
} } else if((str.charAt(i) == "<")) {
else if ((str[i] == "<")) {
var i = (i + 1); var i = (i + 1);
var st = i; var st = i;
while((i < pyjslib_len(str))) { while((i < pyjslib_len(str))) {
if ((str[i] == ">")) { if((str.charAt(i) == ">")) {
var uref = pyjslib_slice(str, st, i); var uref = pyjslib_slice(str, st, i);
if(this._baseURI) { if(this._baseURI) {
var uref = uripath_join(this._baseURI, uref); var uref = uripath_join(this._baseURI, uref);
} } else {
else {
assertFudge((uref.indexOf(":") >= 0), "With no base URI, cannot deal with relative URIs"); assertFudge((uref.indexOf(":") >= 0), "With no base URI, cannot deal with relative URIs");
} }
if((pyjslib_slice(str, (i - 1), i) == "#") && !((pyjslib_slice(uref, -1, null) == "#"))) { if((pyjslib_slice(str, (i - 1), i) == "#") && !((pyjslib_slice(uref, -1, null) == "#"))) {
var uref = (uref + "#"); var uref = (uref + "#");
} }
var symb = this._store.sym(uref); var symb = this._store.sym(uref);
if ((this._variables.indexOf(symb) >= 0)) { if(($rdf.Util.ArrayIndexOf(this._variables, symb) >= 0)) {
res.push(this._variables[symb]); res.push(this._variables[symb]);
} } else {
else {
res.push(symb); res.push(symb);
} }
return(i + 1); return(i + 1);
@ -1013,20 +998,18 @@ __SinkParser.prototype.uri_ref2 = function(str, i, res) {
var i = (i + 1); var i = (i + 1);
} }
throw BadSyntax(this._thisDoc, this.lines, str, j, "unterminated URI reference"); throw BadSyntax(this._thisDoc, this.lines, str, j, "unterminated URI reference");
} } else if(this.keywordsSet) {
else if (this.keywordsSet) {
var v = new pyjslib_List([]); var v = new pyjslib_List([]);
var j = this.bareWord(str, i, v); var j = this.bareWord(str, i, v);
if((j < 0)) { if((j < 0)) {
return -1; return -1;
} }
if ((this.keywords.indexOf(v[0]) >= 0)) { if(($rdf.Util.ArrayIndexOf(this.keywords, v[0]) >= 0)) {
throw BadSyntax(this._thisDoc, this.lines, str, i, (("Keyword \"" + v[0]) + "\" not allowed here.")); throw BadSyntax(this._thisDoc, this.lines, str, i, (("Keyword \"" + v[0]) + "\" not allowed here."));
} }
res.push(this._store.sym((this._bindings[""] + v[0]))); res.push(this._store.sym((this._bindings[""] + v[0])));
return j; return j;
} } else {
else {
return -1; return -1;
} }
}; };
@ -1034,28 +1017,24 @@ __SinkParser.prototype.skipSpace = function(str, i) {
/* /*
Skip white space, newlines and comments. Skip white space, newlines and comments.
return -1 if EOF, else position of first non-ws character*/ return -1 if EOF, else position of first non-ws character*/
var tmp = str;
while (1) { var whitespace = ' \n\r\t\f\x0b\xa0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000';
eol.lastIndex = 0; for(var j = (i ? i : 0); j < str.length; j++) {
var m = eol.exec(str.slice(i)); if(whitespace.indexOf(str.charAt(j)) === -1) {
if ((m == null)) { if(str.charAt(j) === '#') {
str = str.slice(i).replace(/^[^\n]*\n/, "");
i = 0;
j = -1;
} else {
break; break;
} }
this.lines = ( this.lines + 1 ) ;
i += eol.lastIndex;
this.previousLine = this.startOfLine;
this.startOfLine = i;
tabulator.log.debug( ( ( ( "N3 line " + this.lines ) + " " ) + str.slice(this.previousLine, this.startOfLine) ) );
} }
ws.lastIndex = 0;
var m = ws.exec(str.slice(i));
if ((m != null) && (m[0] != "")) {
i += ws.lastIndex;
} }
if ((i == pyjslib_len(str))) { var val = (tmp.length - str.length) + j;
if(val === tmp.length) {
return -1; return -1;
} }
return i; return val;
}; };
__SinkParser.prototype.variable = function (str, i, res) { __SinkParser.prototype.variable = function (str, i, res) {
/* /*
@ -1071,11 +1050,11 @@ __SinkParser.prototype.variable = function(str, i, res) {
} }
var j = (j + 1); var j = (j + 1);
var i = j; var i = j;
if (("0123456789-".indexOf(str[j]) >= 0)) { if(("0123456789-".indexOf(str.charAt(j)) >= 0)) {
throw BadSyntax(this._thisDoc, this.lines, str, j, ( ( "Varible name can't start with '" + str[j] ) + "s'" ) ); throw BadSyntax(this._thisDoc, this.lines, str, j, (("Varible name can't start with '" + str.charAt(j)) + "s'"));
return -1; return -1;
} }
while ((i < pyjslib_len(str)) && (_notNameChars.indexOf(str[i]) < 0)) { while((i < pyjslib_len(str)) && (_notNameChars.indexOf(str.charAt(i)) < 0)) {
var i = (i + 1); var i = (i + 1);
} }
if((this._parentContext == null)) { if((this._parentContext == null)) {
@ -1093,7 +1072,7 @@ __SinkParser.prototype.bareWord = function(str, i, res) {
if((j < 0)) { if((j < 0)) {
return -1; return -1;
} }
var ch = str[j]; var ch = str.charAt(j);
if(("0123456789-".indexOf(ch) >= 0)) { if(("0123456789-".indexOf(ch) >= 0)) {
return -1; return -1;
} }
@ -1101,7 +1080,7 @@ __SinkParser.prototype.bareWord = function(str, i, res) {
return -1; return -1;
} }
var i = j; var i = j;
while ((i < pyjslib_len(str)) && (_notNameChars.indexOf(str[i]) < 0)) { while((i < pyjslib_len(str)) && (_notNameChars.indexOf(str.charAt(i)) < 0)) {
var i = (i + 1); var i = (i + 1);
} }
res.push(pyjslib_slice(str, j, i)); res.push(pyjslib_slice(str, j, i));
@ -1119,7 +1098,7 @@ __SinkParser.prototype.qname = function(str, i, res) {
if((i < 0)) { if((i < 0)) {
return -1; return -1;
} }
var c = str[i]; var c = str.charAt(i);
if(("0123456789-+".indexOf(c) >= 0)) { if(("0123456789-+".indexOf(c) >= 0)) {
return -1; return -1;
} }
@ -1127,38 +1106,34 @@ __SinkParser.prototype.qname = function(str, i, res) {
var ln = c; var ln = c;
var i = (i + 1); var i = (i + 1);
while((i < pyjslib_len(str))) { while((i < pyjslib_len(str))) {
var c = str[i]; var c = str.charAt(i);
if((_notNameChars.indexOf(c) < 0)) { if((_notNameChars.indexOf(c) < 0)) {
var ln = (ln + c); var ln = (ln + c);
var i = (i + 1); var i = (i + 1);
} } else {
else {
break; break;
} }
} }
} } else {
else {
var ln = ""; var ln = "";
} }
if ((i < pyjslib_len(str)) && (str[i] == ":")) { if((i < pyjslib_len(str)) && (str.charAt(i) == ":")) {
var pfx = ln; var pfx = ln;
var i = (i + 1); var i = (i + 1);
var ln = ""; var ln = "";
while((i < pyjslib_len(str))) { while((i < pyjslib_len(str))) {
var c = str[i]; var c = str.charAt(i);
if((_notNameChars.indexOf(c) < 0)) { if((_notNameChars.indexOf(c) < 0)) {
var ln = (ln + c); var ln = (ln + c);
var i = (i + 1); var i = (i + 1);
} } else {
else {
break; break;
} }
} }
res.push(new pyjslib_Tuple([pfx, ln])); res.push(new pyjslib_Tuple([pfx, ln]));
return i; return i;
} } else {
else { if(ln && this.keywordsSet && ($rdf.Util.ArrayIndexOf(this.keywords, ln) < 0)) {
if (ln && this.keywordsSet && (this.keywords.indexOf(ln) < 0)) {
res.push(new pyjslib_Tuple(["", ln])); res.push(new pyjslib_Tuple(["", ln]));
return i; return i;
} }
@ -1169,20 +1144,17 @@ __SinkParser.prototype.object = function(str, i, res) {
var j = this.subject(str, i, res); var j = this.subject(str, i, res);
if((j >= 0)) { if((j >= 0)) {
return j; return j;
} } else {
else {
var j = this.skipSpace(str, i); var j = this.skipSpace(str, i);
if((j < 0)) { if((j < 0)) {
return -1; return -1;
} } else {
else {
var i = j; var i = j;
} }
if ((str[i] == "\"")) { if((str.charAt(i) == "\"")) {
if((pyjslib_slice(str, i, (i + 3)) == "\"\"\"")) { if((pyjslib_slice(str, i, (i + 3)) == "\"\"\"")) {
var delim = "\"\"\""; var delim = "\"\"\"";
} } else {
else {
var delim = "\""; var delim = "\"";
} }
var i = (i + pyjslib_len(delim)); var i = (i + pyjslib_len(delim));
@ -1192,8 +1164,7 @@ __SinkParser.prototype.object = function(str, i, res) {
res.push(this._store.literal(s)); res.push(this._store.literal(s));
diag_progress("New string const ", s, j); diag_progress("New string const ", s, j);
return j; return j;
} } else {
else {
return -1; return -1;
} }
} }
@ -1202,16 +1173,14 @@ __SinkParser.prototype.nodeOrLiteral = function(str, i, res) {
var j = this.node(str, i, res); var j = this.node(str, i, res);
if((j >= 0)) { if((j >= 0)) {
return j; return j;
} } else {
else {
var j = this.skipSpace(str, i); var j = this.skipSpace(str, i);
if((j < 0)) { if((j < 0)) {
return -1; return -1;
} } else {
else {
var i = j; var i = j;
} }
var ch = str[i]; var ch = str.charAt(i);
if(("-+0987654321".indexOf(ch) >= 0)) { if(("-+0987654321".indexOf(ch) >= 0)) {
number_syntax.lastIndex = 0; number_syntax.lastIndex = 0;
var m = number_syntax.exec(str.slice(i)); var m = number_syntax.exec(str.slice(i));
@ -1221,21 +1190,18 @@ __SinkParser.prototype.nodeOrLiteral = function(str, i, res) {
var j = (i + number_syntax.lastIndex); var j = (i + number_syntax.lastIndex);
var val = pyjslib_slice(str, i, j); var val = pyjslib_slice(str, i, j);
if((val.indexOf("e") >= 0)) { if((val.indexOf("e") >= 0)) {
res.push(this._store.literal(parseFloat(val), undefined, kb.sym(FLOAT_DATATYPE))); res.push(this._store.literal(parseFloat(val), undefined, this._store.sym(FLOAT_DATATYPE)));
} } else if((pyjslib_slice(str, i, j).indexOf(".") >= 0)) {
else if ((pyjslib_slice(str, i, j).indexOf(".") >= 0)) { res.push(this._store.literal(parseFloat(val), undefined, this._store.sym(DECIMAL_DATATYPE)));
res.push(this._store.literal(parseFloat(val), undefined, kb.sym(DECIMAL_DATATYPE))); } else {
} res.push(this._store.literal(parseInt(val), undefined, this._store.sym(INTEGER_DATATYPE)));
else {
res.push(this._store.literal(parseInt(val), undefined, kb.sym(INTEGER_DATATYPE)));
} }
return j; return j;
} }
if ((str[i] == "\"")) { if((str.charAt(i) == "\"")) {
if((pyjslib_slice(str, i, (i + 3)) == "\"\"\"")) { if((pyjslib_slice(str, i, (i + 3)) == "\"\"\"")) {
var delim = "\"\"\""; var delim = "\"\"\"";
} } else {
else {
var delim = "\""; var delim = "\"";
} }
var i = (i + pyjslib_len(delim)); var i = (i + pyjslib_len(delim));
@ -1263,8 +1229,7 @@ __SinkParser.prototype.nodeOrLiteral = function(str, i, res) {
} }
res.push(this._store.literal(s, lang, dt)); res.push(this._store.literal(s, lang, dt));
return j; return j;
} } else {
else {
return -1; return -1;
} }
} }
@ -1283,7 +1248,7 @@ __SinkParser.prototype.strconst = function(str, i, delim) {
if((pyjslib_slice(str, j, i) == delim)) { if((pyjslib_slice(str, j, i) == delim)) {
return new pyjslib_Tuple([i, ustr]); return new pyjslib_Tuple([i, ustr]);
} }
if ((str[j] == "\"")) { if((str.charAt(j) == "\"")) {
var ustr = (ustr + "\""); var ustr = (ustr + "\"");
var j = (j + 1); var j = (j + 1);
continue; continue;
@ -1295,16 +1260,14 @@ __SinkParser.prototype.strconst = function(str, i, delim) {
} }
var i = ((j + interesting.lastIndex) - 1); var i = ((j + interesting.lastIndex) - 1);
var ustr = (ustr + pyjslib_slice(str, j, i)); var ustr = (ustr + pyjslib_slice(str, j, i));
var ch = str[i]; var ch = str.charAt(i);
if((ch == "\"")) { if((ch == "\"")) {
var j = i; var j = i;
continue; continue;
} } else if((ch == "\r")) {
else if ((ch == "\r")) {
var j = (i + 1); var j = (i + 1);
continue; continue;
} } else if((ch == "\n")) {
else if ((ch == "\n")) {
if((delim == "\"")) { if((delim == "\"")) {
throw BadSyntax(this._thisDoc, startline, str, i, "newline found in string literal"); throw BadSyntax(this._thisDoc, startline, str, i, "newline found in string literal");
} }
@ -1313,8 +1276,7 @@ __SinkParser.prototype.strconst = function(str, i, delim) {
var j = (i + 1); var j = (i + 1);
this.previousLine = this.startOfLine; this.previousLine = this.startOfLine;
this.startOfLine = j; this.startOfLine = j;
} } else if((ch == "\\")) {
else if ((ch == "\\")) {
var j = (i + 1); var j = (i + 1);
var ch = pyjslib_slice(str, j, (j + 1)); var ch = pyjslib_slice(str, j, (j + 1));
if(!(ch)) { if(!(ch)) {
@ -1322,23 +1284,20 @@ __SinkParser.prototype.strconst = function(str, i, delim) {
} }
var k = string_find("abfrtvn\\\"", ch); var k = string_find("abfrtvn\\\"", ch);
if((k >= 0)) { if((k >= 0)) {
var uch = "\a\b\f\r\t\v\n\\\""[k]; var uch = "\a\b\f\r\t\v\n\\\"".charAt(k);
var ustr = (ustr + uch); var ustr = (ustr + uch);
var j = (j + 1); var j = (j + 1);
} } else if((ch == "u")) {
else if ((ch == "u")) {
var pairFudge = this.uEscape(str, (j + 1), startline); var pairFudge = this.uEscape(str, (j + 1), startline);
var j = pairFudge[0]; var j = pairFudge[0];
var ch = pairFudge[1]; var ch = pairFudge[1];
var ustr = (ustr + ch); var ustr = (ustr + ch);
} } else if((ch == "U")) {
else if ((ch == "U")) {
var pairFudge = this.UEscape(str, (j + 1), startline); var pairFudge = this.UEscape(str, (j + 1), startline);
var j = pairFudge[0]; var j = pairFudge[0];
var ch = pairFudge[1]; var ch = pairFudge[1];
var ustr = (ustr + ch); var ustr = (ustr + ch);
} } else {
else {
throw BadSyntax(this._thisDoc, this.lines, str, i, "bad escape"); throw BadSyntax(this._thisDoc, this.lines, str, i, "bad escape");
} }
} }
@ -1420,4 +1379,6 @@ function stripCR(str) {
function dummyWrite(x) { function dummyWrite(x) {
} }
return SinkParser;
}();

252
chrome/content/zotero/xpcom/rdf/rdfparser.js
View File

@ -61,22 +61,33 @@
* @constructor * @constructor
* @param {RDFStore} store An RDFStore object * @param {RDFStore} store An RDFStore object
*/ */
function RDFParser(store) { $rdf.RDFParser = function (store) {
var RDFParser = {};
/** Standard namespaces that we know how to handle @final /** Standard namespaces that we know how to handle @final
* @member RDFParser * @member RDFParser
*/ */
RDFParser['ns'] = {'RDF': RDFParser['ns'] = {
"http://www.w3.org/1999/02/22-rdf-syntax-ns#", 'RDF': "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
'RDFS': 'RDFS': "http://www.w3.org/2000/01/rdf-schema#"
"http://www.w3.org/2000/01/rdf-schema#"} }
/** DOM Level 2 node type magic numbers @final /** DOM Level 2 node type magic numbers @final
* @member RDFParser * @member RDFParser
*/ */
RDFParser['nodeType'] = {'ELEMENT': 1, 'ATTRIBUTE': 2, 'TEXT': 3, RDFParser['nodeType'] = {
'CDATA_SECTION': 4, 'ENTITY_REFERENCE': 5, 'ELEMENT': 1,
'ENTITY': 6, 'PROCESSING_INSTRUCTION': 7, 'ATTRIBUTE': 2,
'COMMENT': 8, 'DOCUMENT': 9, 'DOCUMENT_TYPE': 10, 'TEXT': 3,
'DOCUMENT_FRAGMENT': 11, 'NOTATION': 12} 'CDATA_SECTION': 4,
'ENTITY_REFERENCE': 5,
'ENTITY': 6,
'PROCESSING_INSTRUCTION': 7,
'COMMENT': 8,
'DOCUMENT': 9,
'DOCUMENT_TYPE': 10,
'DOCUMENT_FRAGMENT': 11,
'NOTATION': 12
}
/** /**
* Frame class for namespace and base URI lookups * Frame class for namespace and base URI lookups
@ -86,7 +97,8 @@ function RDFParser(store) {
* @private * @private
*/ */
this['frameFactory'] = function (parser, parent, element) { this['frameFactory'] = function (parser, parent, element) {
return {'NODE': 1, return {
'NODE': 1,
'ARC': 2, 'ARC': 2,
'parent': parent, 'parent': parent,
'parser': parser, 'parser': parser,
@ -111,7 +123,7 @@ function RDFParser(store) {
/** Add a symbol of a certain type to the this frame */ /** Add a symbol of a certain type to the this frame */
'addSymbol': function (type, uri) { 'addSymbol': function (type, uri) {
uri = Util.uri.join(uri, this['base']) uri = $rdf.Util.uri.join(uri, this['base'])
this['node'] = this['store']['sym'](uri) this['node'] = this['store']['sym'](uri)
this['nodeType'] = type this['nodeType'] = type
}, },
@ -120,8 +132,7 @@ function RDFParser(store) {
'loadTriple': function () { 'loadTriple': function () {
if(this['parent']['parent']['collection']) { if(this['parent']['parent']['collection']) {
this['parent']['parent']['node']['append'](this['node']) this['parent']['parent']['node']['append'](this['node'])
} } else {
else {
this['store']['add'](this['parent']['parent']['node'], this['store']['add'](this['parent']['parent']['node'],
this['parent']['node'], this['parent']['node'],
this['node'], this['node'],
@ -129,32 +140,21 @@ function RDFParser(store) {
} }
if(this['parent']['rdfid'] != null) { // reify if(this['parent']['rdfid'] != null) { // reify
var triple = this['store']['sym']( var triple = this['store']['sym'](
Util.uri.join("#"+this['parent']['rdfid'], $rdf.Util.uri.join("#" + this['parent']['rdfid'], this['base']))
this['base']))
this['store']['add'](triple, this['store']['add'](triple,
this['store']['sym']( this['store']['sym'](RDFParser['ns']['RDF'] + "type"),
RDFParser['ns']['RDF'] this['store']['sym'](RDFParser['ns']['RDF'] + "Statement"),
+"type"),
this['store']['sym'](
RDFParser['ns']['RDF']
+"Statement"),
this['parser']['why']) this['parser']['why'])
this['store']['add'](triple, this['store']['add'](triple,
this['store']['sym']( this['store']['sym'](RDFParser['ns']['RDF'] + "subject"),
RDFParser['ns']['RDF']
+"subject"),
this['parent']['parent']['node'], this['parent']['parent']['node'],
this['parser']['why']) this['parser']['why'])
this['store']['add'](triple, this['store']['add'](triple,
this['store']['sym']( this['store']['sym'](RDFParser['ns']['RDF'] + "predicate"),
RDFParser['ns']['RDF']
+"predicate"),
this['parent']['node'], this['parent']['node'],
this['parser']['why']) this['parser']['why'])
this['store']['add'](triple, this['store']['add'](triple,
this['store']['sym']( this['store']['sym'](RDFParser['ns']['RDF'] + "object"),
RDFParser['ns']['RDF']
+"object"),
this['node'], this['node'],
this['parser']['why']) this['parser']['why'])
} }
@ -166,8 +166,7 @@ function RDFParser(store) {
&& this['parent']['parent'] != null && this['parent']['parent'] != null
&& this['nodeType'] == this['NODE'] && this['nodeType'] == this['NODE']
&& this['parent']['nodeType'] == this['ARC'] && this['parent']['nodeType'] == this['ARC']
&& this['parent']['parent']['nodeType'] && this['parent']['parent']['nodeType'] == this['NODE'])
== this['NODE'])
}, },
/** Add a symbolic node to this frame */ /** Add a symbolic node to this frame */
@ -201,7 +200,9 @@ function RDFParser(store) {
} else { } else {
this['node'] = this['parser']['bnodes'][id] = this['store']['bnode']() this['node'] = this['parser']['bnodes'][id] = this['store']['bnode']()
} }
} else { this['node'] = this['store']['bnode']() } } else {
this['node'] = this['store']['bnode']()
}
this['nodeType'] = this['NODE'] this['nodeType'] = this['NODE']
if(this['isTripleToLoad']()) { if(this['isTripleToLoad']()) {
@ -223,8 +224,7 @@ function RDFParser(store) {
this['node'] = this['store']['literal']( this['node'] = this['store']['literal'](
value, "", this['store']['sym']( value, "", this['store']['sym'](
this['parent']['datatype'])) this['parent']['datatype']))
} } else {
else {
this['node'] = this['store']['literal']( this['node'] = this['store']['literal'](
value, this['lang']) value, this['lang'])
} }
@ -236,6 +236,28 @@ function RDFParser(store) {
} }
} }
//from the OpenLayers source .. needed to get around IE problems.
this['getAttributeNodeNS'] = function (node, uri, name) {
var attributeNode = null;
if(node.getAttributeNodeNS) {
attributeNode = node.getAttributeNodeNS(uri, name);
} else {
var attributes = node.attributes;
var potentialNode, fullName;
for(var i = 0; i < attributes.length; ++i) {
potentialNode = attributes[i];
if(potentialNode.namespaceURI == uri) {
fullName = (potentialNode.prefix) ? (potentialNode.prefix + ":" + name) : name;
if(fullName == potentialNode.nodeName) {
attributeNode = potentialNode;
break;
}
}
}
}
return attributeNode;
}
/** Our triple store reference @private */ /** Our triple store reference @private */
this['store'] = store this['store'] = store
/** Our identified blank nodes @private */ /** Our identified blank nodes @private */
@ -259,32 +281,25 @@ function RDFParser(store) {
this['cleanParser']() this['cleanParser']()
// figure out the root element // figure out the root element
var root = document.documentElement; //this is faster, I think, cross-browser issue? well, DOM 2 //var root = document.documentElement; //this is faster, I think, cross-browser issue? well, DOM 2
/*
if(document['nodeType'] == RDFParser['nodeType']['DOCUMENT']) { if(document['nodeType'] == RDFParser['nodeType']['DOCUMENT']) {
for(var c = 0; c < children['length']; c++) { for(var c = 0; c < children['length']; c++) {
if (children[c]['nodeType'] if(children[c]['nodeType'] == RDFParser['nodeType']['ELEMENT']) {
== RDFParser['nodeType']['ELEMENT']) {
var root = children[c] var root = children[c]
break break
} }
} }
} } else if(document['nodeType'] == RDFParser['nodeType']['ELEMENT']) {
else if (document['nodeType'] == RDFParser['nodeType']['ELEMENT']) {
var root = document var root = document
} } else {
else { throw new Error("RDFParser: can't find root in " + base + ". Halting. ")
throw new Error("RDFParser: can't find root in " + base
+ ". Halting. ")
return false return false
} }
*/
this['why'] = why this['why'] = why
// our topmost frame // our topmost frame
var f = this['frameFactory'](this) var f = this['frameFactory'](this)
this['base'] = base this['base'] = base
f['base'] = base f['base'] = base
@ -296,26 +311,35 @@ function RDFParser(store) {
this['parseDOM'] = function (frame) { this['parseDOM'] = function (frame) {
// a DOM utility function used in parsing // a DOM utility function used in parsing
var elementURI = function (el) { var elementURI = function (el) {
var result = "";
if(el['namespaceURI'] == null) { if(el['namespaceURI'] == null) {
throw new Error("RDF/XML syntax error: No namespace for " throw new Error("RDF/XML syntax error: No namespace for "
+ el['localName'] + " in " + this.base) + el['localName'] + " in " + this.base)
} }
return el['namespaceURI'] + el['localName'] if(el['namespaceURI']) {
result = result + el['namespaceURI'];
}
if(el['localName']) {
result = result + el['localName'];
} else if(el['nodeName']) {
if(el['nodeName'].indexOf(":") >= 0)
result = result + el['nodeName'].split(":")[1];
else
result = result + el['nodeName'];
}
return result;
} }
var dig = true // if we'll dig down in the tree on the next iter var dig = true // if we'll dig down in the tree on the next iter
while(frame['parent']) { while(frame['parent']) {
var dom = frame['element'] var dom = frame['element']
var attrs = dom['attributes'] var attrs = dom['attributes']
if (dom['nodeType'] if(dom['nodeType'] == RDFParser['nodeType']['TEXT']
== RDFParser['nodeType']['TEXT'] || dom['nodeType'] == RDFParser['nodeType']['CDATA_SECTION']) {
|| dom['nodeType'] //we have a literal
== RDFParser['nodeType']['CDATA_SECTION']) {//we have a literal
frame['addLiteral'](dom['nodeValue']) frame['addLiteral'](dom['nodeValue'])
} } else if(elementURI(dom) != RDFParser['ns']['RDF'] + "RDF") {
else if (elementURI(dom) // not root
!= RDFParser['ns']['RDF']+"RDF") { // not root
if(frame['parent'] && frame['parent']['collection']) { if(frame['parent'] && frame['parent']['collection']) {
// we're a collection element // we're a collection element
frame['addCollectionArc']() frame['addCollectionArc']()
@ -325,47 +349,41 @@ function RDFParser(store) {
if(!frame['parent'] || !frame['parent']['nodeType'] if(!frame['parent'] || !frame['parent']['nodeType']
|| frame['parent']['nodeType'] == frame['ARC']) { || frame['parent']['nodeType'] == frame['ARC']) {
// we need a node // we need a node
var about =dom['getAttributeNodeNS']( var about = this['getAttributeNodeNS'](dom, RDFParser['ns']['RDF'], "about")
RDFParser['ns']['RDF'],"about") var rdfid = this['getAttributeNodeNS'](dom, RDFParser['ns']['RDF'], "ID")
var rdfid =dom['getAttributeNodeNS'](
RDFParser['ns']['RDF'],"ID")
if(about && rdfid) { if(about && rdfid) {
throw new Error("RDFParser: " + dom['nodeName'] throw new Error("RDFParser: " + dom['nodeName']
+ " has both rdf:id and rdf:about." + " has both rdf:id and rdf:about." + " Halting. Only one of these"
+ " Halting. Only one of these" + " properties may be specified on a" + " node.");
+ " properties may be specified on a"
+ " node.");
} }
if(about == null && rdfid) { if(about == null && rdfid) {
frame['addNode']("#" + rdfid['nodeValue']) frame['addNode']("#" + rdfid['nodeValue'])
dom['removeAttributeNode'](rdfid) dom['removeAttributeNode'](rdfid)
} } else if(about == null && rdfid == null) {
else if (about == null && rdfid == null) { var bnid = this['getAttributeNodeNS'](dom, RDFParser['ns']['RDF'], "nodeID")
var bnid = dom['getAttributeNodeNS'](
RDFParser['ns']['RDF'],"nodeID")
if(bnid) { if(bnid) {
frame['addBNode'](bnid['nodeValue']) frame['addBNode'](bnid['nodeValue'])
dom['removeAttributeNode'](bnid) dom['removeAttributeNode'](bnid)
} else { frame['addBNode']() } } else {
frame['addBNode']()
} }
else { } else {
frame['addNode'](about['nodeValue']) frame['addNode'](about['nodeValue'])
dom['removeAttributeNode'](about) dom['removeAttributeNode'](about)
} }
// Typed nodes // Typed nodes
var rdftype = dom['getAttributeNodeNS']( var rdftype = this['getAttributeNodeNS'](dom, RDFParser['ns']['RDF'], "type")
RDFParser['ns']['RDF'],"type") if(RDFParser['ns']['RDF'] + "Description" != elementURI(dom)) {
if (RDFParser['ns']['RDF']+"Description" rdftype = {
!= elementURI(dom)) { 'nodeValue': elementURI(dom)
rdftype = {'nodeValue': elementURI(dom)} }
} }
if(rdftype != null) { if(rdftype != null) {
this['store']['add'](frame['node'], this['store']['add'](frame['node'],
this['store']['sym'](RDFParser['ns']['RDF'] + "type"),
this['store']['sym']( this['store']['sym'](
RDFParser['ns']['RDF']+"type"), $rdf.Util.uri.join(
this['store']['sym'](
Util.uri.join(
rdftype['nodeValue'], rdftype['nodeValue'],
frame['base'])), frame['base'])),
this['why']) this['why'])
@ -377,31 +395,27 @@ function RDFParser(store) {
// Property Attributes // Property Attributes
for(var x = attrs['length'] - 1; x >= 0; x--) { for(var x = attrs['length'] - 1; x >= 0; x--) {
this['store']['add'](frame['node'], this['store']['add'](frame['node'],
this['store']['sym']( this['store']['sym'](elementURI(attrs[x])),
elementURI(attrs[x])),
this['store']['literal']( this['store']['literal'](
attrs[x]['nodeValue'], attrs[x]['nodeValue'],
frame['lang']), frame['lang']),
this['why']) this['why'])
} }
} } else {
else { // we should add an arc (or implicit bnode+arc) // we should add an arc (or implicit bnode+arc)
frame['addArc'](elementURI(dom)) frame['addArc'](elementURI(dom))
// save the arc's rdf:ID if it has one // save the arc's rdf:ID if it has one
if(this['reify']) { if(this['reify']) {
var rdfid = dom['getAttributeNodeNS']( var rdfid = this['getAttributeNodeNS'](dom, RDFParser['ns']['RDF'], "ID")
RDFParser['ns']['RDF'],"ID")
if(rdfid) { if(rdfid) {
frame['rdfid'] = rdfid['nodeValue'] frame['rdfid'] = rdfid['nodeValue']
dom['removeAttributeNode'](rdfid) dom['removeAttributeNode'](rdfid)
} }
} }
var parsetype = dom['getAttributeNodeNS']( var parsetype = this['getAttributeNodeNS'](dom, RDFParser['ns']['RDF'], "parseType")
RDFParser['ns']['RDF'],"parseType") var datatype = this['getAttributeNodeNS'](dom, RDFParser['ns']['RDF'], "datatype")
var datatype = dom['getAttributeNodeNS'](
RDFParser['ns']['RDF'],"datatype")
if(datatype) { if(datatype) {
frame['datatype'] = datatype['nodeValue'] frame['datatype'] = datatype['nodeValue']
dom['removeAttributeNode'](datatype) dom['removeAttributeNode'](datatype)
@ -410,20 +424,17 @@ function RDFParser(store) {
if(parsetype) { if(parsetype) {
var nv = parsetype['nodeValue'] var nv = parsetype['nodeValue']
if(nv == "Literal") { if(nv == "Literal") {
frame['datatype'] frame['datatype'] = RDFParser['ns']['RDF'] + "XMLLiteral"
= RDFParser['ns']['RDF']+"XMLLiteral"
// (this.buildFrame(frame)).addLiteral(dom) // (this.buildFrame(frame)).addLiteral(dom)
// should work but doesn't // should work but doesn't
frame = this['buildFrame'](frame) frame = this['buildFrame'](frame)
frame['addLiteral'](dom) frame['addLiteral'](dom)
dig = false dig = false
} } else if(nv == "Resource") {
else if (nv == "Resource") {
frame = this['buildFrame'](frame, frame['element']) frame = this['buildFrame'](frame, frame['element'])
frame['parent']['element'] = null frame['parent']['element'] = null
frame['addBNode']() frame['addBNode']()
} } else if(nv == "Collection") {
else if (nv == "Collection") {
frame = this['buildFrame'](frame, frame['element']) frame = this['buildFrame'](frame, frame['element'])
frame['parent']['element'] = null frame['parent']['element'] = null
frame['addCollection']() frame['addCollection']()
@ -432,10 +443,8 @@ function RDFParser(store) {
} }
if(attrs['length'] != 0) { if(attrs['length'] != 0) {
var resource = dom['getAttributeNodeNS']( var resource = this['getAttributeNodeNS'](dom, RDFParser['ns']['RDF'], "resource")
RDFParser['ns']['RDF'],"resource") var bnid = this['getAttributeNodeNS'](dom, RDFParser['ns']['RDF'], "nodeID")
var bnid = dom['getAttributeNodeNS'](
RDFParser['ns']['RDF'],"nodeID")
frame = this['buildFrame'](frame) frame = this['buildFrame'](frame)
if(resource) { if(resource) {
@ -445,14 +454,15 @@ function RDFParser(store) {
if(bnid) { if(bnid) {
frame['addBNode'](bnid['nodeValue']) frame['addBNode'](bnid['nodeValue'])
dom['removeAttributeNode'](bnid) dom['removeAttributeNode'](bnid)
} else { frame['addBNode']() } } else {
frame['addBNode']()
}
} }
for(var x = attrs['length'] - 1; x >= 0; x--) { for(var x = attrs['length'] - 1; x >= 0; x--) {
var f = this['buildFrame'](frame) var f = this['buildFrame'](frame)
f['addArc'](elementURI(attrs[x])) f['addArc'](elementURI(attrs[x]))
if (elementURI(attrs[x]) if(elementURI(attrs[x]) == RDFParser['ns']['RDF'] + "type") {
==RDFParser['ns']['RDF']+"type"){
(this['buildFrame'](f))['addNode']( (this['buildFrame'](f))['addNode'](
attrs[x]['nodeValue']) attrs[x]['nodeValue'])
} else { } else {
@ -460,13 +470,11 @@ function RDFParser(store) {
attrs[x]['nodeValue']) attrs[x]['nodeValue'])
} }
} }
} } else if(dom['childNodes']['length'] == 0) {
else if (dom['childNodes']['length'] == 0) {
(this['buildFrame'](frame))['addLiteral']("") (this['buildFrame'](frame))['addLiteral']("")
} }
} }
} // rdf:RDF } // rdf:RDF
// dig dug // dig dug
dom = frame['element'] dom = frame['element']
while(frame['parent']) { while(frame['parent']) {
@ -478,27 +486,22 @@ function RDFParser(store) {
var candidate = dom['childNodes'][frame['lastChild']] var candidate = dom['childNodes'][frame['lastChild']]
if(candidate == null || !dig) { if(candidate == null || !dig) {
frame['terminateFrame']() frame['terminateFrame']()
if (!(frame = frame['parent'])) { break } // done if(!(frame = frame['parent'])) {
break
} // done
dom = frame['element'] dom = frame['element']
dig = true dig = true
} } else if((candidate['nodeType'] != RDFParser['nodeType']['ELEMENT']
else if ((candidate['nodeType'] && candidate['nodeType'] != RDFParser['nodeType']['TEXT']
!= RDFParser['nodeType']['ELEMENT'] && candidate['nodeType'] != RDFParser['nodeType']['CDATA_SECTION'])
&& candidate['nodeType'] || ((candidate['nodeType'] == RDFParser['nodeType']['TEXT']
!= RDFParser['nodeType']['TEXT'] || candidate['nodeType'] == RDFParser['nodeType']['CDATA_SECTION'])
&& candidate['nodeType']
!= RDFParser['nodeType']['CDATA_SECTION'])
|| ((candidate['nodeType']
== RDFParser['nodeType']['TEXT']
|| candidate['nodeType']
== RDFParser['nodeType']['CDATA_SECTION'])
&& dom['childNodes']['length'] != 1)) { && dom['childNodes']['length'] != 1)) {
frame['lastChild']++ frame['lastChild']++
} } else {
else { // not a leaf // not a leaf
frame['lastChild']++ frame['lastChild']++;
frame = this['buildFrame'](pframe, frame = this['buildFrame'](pframe, dom['childNodes'][frame['lastChild'] - 1])
dom['childNodes'][frame['lastChild']-1])
break break
} }
} }
@ -549,9 +552,8 @@ function RDFParser(store) {
if(attrs[x].name.slice(0, 6) == 'xmlns:') { if(attrs[x].name.slice(0, 6) == 'xmlns:') {
var uri = attrs[x].nodeValue; var uri = attrs[x].nodeValue;
// alert('base for namespac attr:'+this.base); // alert('base for namespac attr:'+this.base);
if (this.base) uri = Util.uri.join(uri, this.base); if(this.base) uri = $rdf.Util.uri.join(uri, this.base);
this.store.setPrefixForURI(attrs[x].name.slice(6), this.store.setPrefixForURI(attrs[x].name.slice(6), uri);
uri);
} }
// alert('rdfparser: xml atribute: '+attrs[x].name) //@@ // alert('rdfparser: xml atribute: '+attrs[x].name) //@@
element['removeAttributeNode'](attrs[x]) element['removeAttributeNode'](attrs[x])

414
chrome/content/zotero/xpcom/rdf/serialize.js
View File

@ -6,8 +6,11 @@
** Bug: can't serialize http://data.semanticweb.org/person/abraham-bernstein/rdf ** Bug: can't serialize http://data.semanticweb.org/person/abraham-bernstein/rdf
** in XML (from mhausenblas) ** in XML (from mhausenblas)
*/ */
// @@@ Check the whole toStr thing tosee whetehr it still makes sense -- tbl
//
$rdf.Serializer = function () {
__Serializer = function(){ var __Serializer = function (store) {
this.flags = ""; this.flags = "";
this.base = null; this.base = null;
this.prefixes = []; this.prefixes = [];
@ -15,17 +18,22 @@ __Serializer = function(){
this.prefixchars = "abcdefghijklmnopqustuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; this.prefixchars = "abcdefghijklmnopqustuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
this.incoming = null; // Array not calculated yet this.incoming = null; // Array not calculated yet
this.formulas = []; // remebering original formulae from hashes this.formulas = []; // remebering original formulae from hashes
this.store = store;
/* pass */ /* pass */
} }
Serializer = function() {return new __Serializer()}; var Serializer = function (store) {
return new __Serializer(store)
};
__Serializer.prototype.setBase = function(base) __Serializer.prototype.setBase = function (base) {
{ this.base = base }; this.base = base
};
__Serializer.prototype.setFlags = function(flags) __Serializer.prototype.setFlags = function (flags) {
{ this.flags = flags?flags: '' }; this.flags = flags ? flags : ''
};
__Serializer.prototype.toStr = function (x) { __Serializer.prototype.toStr = function (x) {
@ -42,7 +50,7 @@ __Serializer.prototype.fromStr = function(s) {
if(!x) alert('No formula object for ' + s) if(!x) alert('No formula object for ' + s)
return x; return x;
} }
return kb.fromNT(s); return this.store.fromNT(s);
}; };
@ -79,13 +87,18 @@ __Serializer.prototype.makeUpPrefix = function(uri) {
pok = pp; pok = pp;
return true return true
} }
for (var ns in sz.prefixes) namespaces[sz.prefixes[ns]] = ns; // reverse index for(var ns in sz.prefixes) {
namespaces[sz.prefixes[ns]] = ns; // reverse index
}
if('#/'.indexOf(p[p.length - 1]) >= 0) p = p.slice(0, -1); if('#/'.indexOf(p[p.length - 1]) >= 0) p = p.slice(0, -1);
var slash = p.lastIndexOf('/'); var slash = p.lastIndexOf('/');
if(slash >= 0) p = p.slice(slash + 1); if(slash >= 0) p = p.slice(slash + 1);
var i = 0; var i = 0;
while(i < p.length) while(i < p.length)
if (sz.prefixchars.indexOf(p[i])) i++; else break; if(sz.prefixchars.indexOf(p[i]))
i++;
else
break;
p = p.slice(0, i); p = p.slice(0, i);
if(p.length < 6 && canUse(p)) return pok; // exact i sbest if(p.length < 6 && canUse(p)) return pok; // exact i sbest
if(canUse(p.slice(0, 3))) return pok; if(canUse(p.slice(0, 3))) return pok;
@ -97,84 +110,174 @@ __Serializer.prototype.makeUpPrefix = function(uri) {
} }
/* The scan is to find out which nodes will have to be the roots of trees
** in the serialized form. This will be any symbols, and any bnodes
** which hve more or less than one incoming arc, and any bnodes which have
** one incoming arc but it is an uninterrupted loop of such nodes back to itself.
** This should be kept linear time with repect to the number of statements.
** Note it does not use any indexing.
*/
// Todo: // Todo:
// - Sort the statements by subject, pred, object // - Sort the statements by subject, pred, object
// - do stuff about the docu first and then (or first) about its primary topic. // - do stuff about the docu first and then (or first) about its primary topic.
__Serializer.prototype.rootSubjects = function (sts) { __Serializer.prototype.rootSubjects = function (sts) {
var incoming = {}; var incoming = {};
var subjects = {}; var subjects = {};
var sz = this; var sz = this;
var allBnodes = {};
/* This scan is to find out which nodes will have to be the roots of trees
** in the serialized form. This will be any symbols, and any bnodes
** which hve more or less than one incoming arc, and any bnodes which have
** one incoming arc but it is an uninterrupted loop of such nodes back to itself.
** This should be kept linear time with repect to the number of statements.
** Note it does not use any indexing of the store.
*/
tabulator.log.debug('serialize.js Find bnodes with only one incoming arc\n')
for(var i = 0; i < sts.length; i++) { for(var i = 0; i < sts.length; i++) {
var st = sts[i];
[st.subject, st.predicate, st.object].map(function (y) {
if(y.termType == 'bnode') {
allBnodes[y.toNT()] = true
}
});
var x = sts[i].object; var x = sts[i].object;
if(!incoming[x]) incoming[x] = []; if(!incoming[x]) incoming[x] = [];
incoming[x].push(sts[i].subject) // List of things which will cause this to be printed incoming[x].push(st.subject) // List of things which will cause this to be printed
var ss = subjects[sz.toStr(sts[i].subject)]; // Statements with this as subject var ss = subjects[sz.toStr(st.subject)]; // Statements with this as subject
if(!ss) ss = []; if(!ss) ss = [];
ss.push(sts[i]); ss.push(st);
subjects[this.toStr(sts[i].subject)] = ss; // Make hash. @@ too slow for formula? subjects[this.toStr(st.subject)] = ss; // Make hash. @@ too slow for formula?
tabulator.log.debug(' sz potential subject: '+sts[i].subject) //$rdf.log.debug(' sz potential subject: '+sts[i].subject)
} }
var roots = []; var roots = [];
var loopBreakers = {};
function accountedFor(x, start) {
if (x.termType != 'bnode') return true; // will be subject
var zz = incoming[x];
if (!zz || zz.length != 1) return true;
if (loopBreakers[x]) return true;
if (zz[0] == start) return false;
return accountedFor(zz[0], start);
}
for(var xNT in subjects) { for(var xNT in subjects) {
var x = sz.fromStr(xNT); var x = sz.fromStr(xNT);
if((x.termType != 'bnode') || !incoming[x] || (incoming[x].length != 1)) { if((x.termType != 'bnode') || !incoming[x] || (incoming[x].length != 1)) {
roots.push(x); roots.push(x);
tabulator.log.debug(' sz actual subject -: ' + x) //$rdf.log.debug(' sz actual subject -: ' + x)
continue; continue;
} }
if (accountedFor(incoming[x][0]), x) {
continue;
} }
roots.push(x); this.incoming = incoming; // Keep for serializing @@ Bug for nested formulas
tabulator.log.debug(' sz potential subject *: '+sts[i].subject) //////////// New bit for CONNECTED bnode loops:frootshash
loopBreakers[x] = 1; // This scans to see whether the serialization is gpoing to lead to a bnode loop
// and at the same time accumulates a list of all bnodes mentioned.
// This is in fact a cut down N3 serialization
/*
tabulator.log.debug('serialize.js Looking for connected bnode loops\n')
for (var i=0; i<sts.length; i++) { // @@TBL
// dump('\t'+sts[i]+'\n');
} }
this.incoming = incoming; // Keep for serializing var doneBnodesNT = {};
return [roots, subjects]; function dummyPropertyTree(subject, subjects, rootsHash) {
// dump('dummyPropertyTree('+subject+'...)\n');
var sts = subjects[sz.toStr(subject)]; // relevant statements
for (var i=0; i<sts.length; i++) {
dummyObjectTree(sts[i].object, subjects, rootsHash);
}
}
// Convert a set of statements into a nested tree of lists and strings
// @param force, "we know this is a root, do it anyway. It isn't a loop."
function dummyObjectTree(obj, subjects, rootsHash, force) {
// dump('dummyObjectTree('+obj+'...)\n');
if (obj.termType == 'bnode' && (subjects[sz.toStr(obj)] &&
(force || (rootsHash[obj.toNT()] == undefined )))) {// and there are statements
if (doneBnodesNT[obj.toNT()]) { // Ah-ha! a loop
throw "Serializer: Should be no loops "+obj;
}
doneBnodesNT[obj.toNT()] = true;
return dummyPropertyTree(obj, subjects, rootsHash);
}
return dummyTermToN3(obj, subjects, rootsHash);
}
// Scan for bnodes nested inside lists too
function dummyTermToN3(expr, subjects, rootsHash) {
if (expr.termType == 'bnode') doneBnodesNT[expr.toNT()] = true;
tabulator.log.debug('serialize: seen '+expr);
if (expr.termType == 'collection') {
for (i=0; i<expr.elements.length; i++) {
if (expr.elements[i].termType == 'bnode')
dummyObjectTree(expr.elements[i], subjects, rootsHash);
}
return;
}
}
// The tree for a subject
function dummySubjectTree(subject, subjects, rootsHash) {
// dump('dummySubjectTree('+subject+'...)\n');
if (subject.termType == 'bnode' && !incoming[subject])
return dummyObjectTree(subject, subjects, rootsHash, true); // Anonymous bnode subject
dummyTermToN3(subject, subjects, rootsHash);
dummyPropertyTree(subject, subjects, rootsHash);
}
*/
// Now do the scan using existing roots
tabulator.log.debug('serialize.js Dummy serialize to check for missing nodes')
var rootsHash = {};
for(var i = 0; i < roots.length; i++) rootsHash[roots[i].toNT()] = true;
/*
for (var i=0; i<roots.length; i++) {
var root = roots[i];
dummySubjectTree(root, subjects, rootsHash);
}
// dump('Looking for mising bnodes...\n')
// Now in new roots for anythig not acccounted for
// Now we check for any bndoes which have not been covered.
// Such bnodes must be in isolated rings of pure bnodes.
// They each have incoming link of 1.
tabulator.log.debug('serialize.js Looking for connected bnode loops\n')
for (;;) {
var bnt;
var found = null;
for (bnt in allBnodes) { // @@ Note: not repeatable. No canonicalisation
if (doneBnodesNT[bnt]) continue;
found = bnt; // Ah-ha! not covered
break;
}
if (found == null) break; // All done - no bnodes left out/
// dump('Found isolated bnode:'+found+'\n');
doneBnodesNT[bnt] = true;
var root = this.store.fromNT(found);
roots.push(root); // Add a new root
rootsHash[found] = true;
tabulator.log.debug('isolated bnode:'+found+', subjects[found]:'+subjects[found]+'\n');
if (subjects[found] == undefined) {
for (var i=0; i<sts.length; i++) {
// dump('\t'+sts[i]+'\n');
}
throw "Isolated node should be a subject" +found;
}
dummySubjectTree(root, subjects, rootsHash); // trace out the ring
}
// dump('Done bnode adjustments.\n')
*/
return {
'roots': roots,
'subjects': subjects,
'rootsHash': rootsHash,
'incoming': incoming
};
} }
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
__Serializer.prototype.toN3 = function (f) { __Serializer.prototype.toN3 = function (f) {
return this.statementsToN3(f.statements); return this.statementsToN3(f.statements);
} }
__Serializer.prototype._notQNameChars = "\t\r\n !\"#$%&'()*.,+/;<=>?@[\\]^`{|}~"; __Serializer.prototype._notQNameChars = "\t\r\n !\"#$%&'()*.,+/;<=>?@[\\]^`{|}~";
__Serializer.prototype._notNameChars = __Serializer.prototype._notNameChars = (__Serializer.prototype._notQNameChars + ":");
( __Serializer.prototype._notQNameChars + ":" ) ;
__Serializer.prototype.statementsToN3 = function (sts) { __Serializer.prototype.statementsToN3 = function (sts) {
var indent = 4; var indent = 4;
var width = 80; var width = 80;
// var subjects = null; // set later
var sz = this; var sz = this;
var namespaceCounts = []; // which have been used var namespaceCounts = []; // which have been used
var predMap = {
predMap = {
'http://www.w3.org/2002/07/owl#sameAs': '=', 'http://www.w3.org/2002/07/owl#sameAs': '=',
'http://www.w3.org/2000/10/swap/log#implies': '=>', 'http://www.w3.org/2000/10/swap/log#implies': '=>',
'http://www.w3.org/1999/02/22-rdf-syntax-ns#type': 'a' 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type': 'a'
@ -184,14 +287,13 @@ __Serializer.prototype.statementsToN3 = function(sts) {
////////////////////////// Arrange the bits of text ////////////////////////// Arrange the bits of text
var spaces = function (n) { var spaces = function (n) {
var s = ''; var s = '';
for(var i = 0; i < n; i++) s += ' '; for(var i = 0; i < n; i++) s += ' ';
return s return s
} }
treeToLine = function(tree) { var treeToLine = function (tree) {
var str = ''; var str = '';
for(var i = 0; i < tree.length; i++) { for(var i = 0; i < tree.length; i++) {
var branch = tree[i]; var branch = tree[i];
@ -203,7 +305,7 @@ __Serializer.prototype.statementsToN3 = function(sts) {
} }
// Convert a nested tree of lists and strings to a string // Convert a nested tree of lists and strings to a string
treeToString = function(tree, level) { var treeToString = function (tree, level) {
var str = ''; var str = '';
var lastLength = 100000; var lastLength = 100000;
if(!level) level = 0; if(!level) level = 0;
@ -211,9 +313,9 @@ __Serializer.prototype.statementsToN3 = function(sts) {
var branch = tree[i]; var branch = tree[i];
if(typeof branch != 'string') { if(typeof branch != 'string') {
var substr = treeToString(branch, level + 1); var substr = treeToString(branch, level + 1);
if ( if(substr.length < 10 * (width - indent * level)
substr.length < 10*(width-indent*level) && substr.indexOf('"""') < 0) {
&& substr.indexOf('"""') < 0) {// Don't mess up multiline strings // Don't mess up multiline strings
var line = treeToLine(branch); var line = treeToLine(branch);
if(line.length < (width - indent * level)) { if(line.length < (width - indent * level)) {
branch = ' ' + line; // @@ Hack: treat as string below branch = ' ' + line; // @@ Hack: treat as string below
@ -252,38 +354,36 @@ __Serializer.prototype.statementsToN3 = function(sts) {
////////////////////////////////////////////// Structure for N3 ////////////////////////////////////////////// Structure for N3
// Convert a set of statements into a nested tree of lists and strings
function statementListToTree(statements) { function statementListToTree(statements) {
// print('Statement tree for '+statements.length); // print('Statement tree for '+statements.length);
var res = []; var res = [];
var pair = sz.rootSubjects(statements); var stats = sz.rootSubjects(statements);
var roots = pair[0]; var roots = stats.roots;
// print('Roots: '+roots)
var subjects = pair[1];
var results = [] var results = []
for(var i = 0; i < roots.length; i++) { for(var i = 0; i < roots.length; i++) {
var root = roots[i]; var root = roots[i];
results.push(subjectTree(root, subjects)) results.push(subjectTree(root, stats))
} }
return results; return results;
} }
// The tree for a subject // The tree for a subject
function subjectTree(subject, subjects) { function subjectTree(subject, stats) {
if (subject.termType == 'bnode' && !sz.incoming[subject]) if(subject.termType == 'bnode' && !stats.incoming[subject])
return objectTree(subject, subjects).concat(["."]); // Anonymous bnode subject return objectTree(subject, stats, true).concat(["."]); // Anonymous bnode subject
return [ termToN3(subject, subjects) ].concat([propertyTree(subject, subjects)]).concat(["."]); return [termToN3(subject, stats)].concat([propertyTree(subject, stats)]).concat(["."]);
} }
// The property tree for a single subject or anonymous node // The property tree for a single subject or anonymous node
function propertyTree(subject, subjects) { function propertyTree(subject, stats) {
// print('Proprty tree for '+subject); // print('Proprty tree for '+subject);
var results = [] var results = []
var lastPred = null; var lastPred = null;
var sts = subjects[sz.toStr(subject)]; // relevant statements var sts = stats.subjects[sz.toStr(subject)]; // relevant statements
if(typeof sts == 'undefined') { if(typeof sts == 'undefined') {
alert('Cant find statements for '+subject); throw('Cant find statements for ' + subject);
} }
sts.sort(); sts.sort();
var objects = []; var objects = [];
@ -297,34 +397,34 @@ __Serializer.prototype.statementsToN3 = function(sts) {
objects = []; objects = [];
} }
results.push(predMap[st.predicate.uri] ? results.push(predMap[st.predicate.uri] ?
predMap[st.predicate.uri] : termToN3(st.predicate, subjects)); predMap[st.predicate.uri] :
termToN3(st.predicate, stats));
} }
lastPred = st.predicate.uri; lastPred = st.predicate.uri;
objects.push(objectTree(st.object, subjects)); objects.push(objectTree(st.object, stats));
} }
results = results.concat([objects]); results = results.concat([objects]);
return results; return results;
} }
// Convert a set of statements into a nested tree of lists and strings function objectTree(obj, stats, force) {
function objectTree(obj, subjects) { if(obj.termType == 'bnode'
if (obj.termType == 'bnode' && subjects[sz.toStr(obj)]) // and there are statements && stats.subjects[sz.toStr(obj)]
return ['['].concat(propertyTree(obj, subjects)).concat([']']); // and there are statements
return termToN3(obj, subjects); && (force || stats.rootsHash[obj.toNT()] == undefined)) // and not a root
return ['['].concat(propertyTree(obj, stats)).concat([']']);
return termToN3(obj, stats);
} }
////////////////////////////////////////////// Atomic Terms function termToN3(expr, stats) {
// Deal with term level things and nesting with no bnode structure
function termToN3(expr, subjects) {
switch(expr.termType) { switch(expr.termType) {
case 'bnode': case 'bnode':
case 'variable': return expr.toNT(); case 'variable':
return expr.toNT();
case 'literal': case 'literal':
var str = stringToN3(expr.value); var str = stringToN3(expr.value);
if(expr.lang) str += '@' + expr.lang; if(expr.lang) str += '@' + expr.lang;
if (expr.dt) str+= '^^' + termToN3(expr.dt, subjects); if(expr.datatype) str += '^^' + termToN3(expr.datatype, stats);
return str; return str;
case 'symbol': case 'symbol':
return symbolToN3(expr.uri); return symbolToN3(expr.uri);
@ -335,7 +435,7 @@ __Serializer.prototype.statementsToN3 = function(sts) {
case 'collection': case 'collection':
var res = ['(']; var res = ['('];
for(i = 0; i < expr.elements.length; i++) { for(i = 0; i < expr.elements.length; i++) {
res.push( [ objectTree(expr.elements[i], subjects) ]); res.push([objectTree(expr.elements[i], stats)]);
} }
res.push(')'); res.push(')');
return res; return res;
@ -346,6 +446,8 @@ __Serializer.prototype.statementsToN3 = function(sts) {
} }
} }
////////////////////////////////////////////// Atomic Terms
// Deal with term level things and nesting with no bnode structure
function symbolToN3(uri) { // c.f. symbolString() in notation3.py function symbolToN3(uri) { // c.f. symbolString() in notation3.py
var j = uri.indexOf('#'); var j = uri.indexOf('#');
if(j < 0 && sz.flags.indexOf('/') < 0) { if(j < 0 && sz.flags.indexOf('/') < 0) {
@ -355,16 +457,18 @@ __Serializer.prototype.statementsToN3 = function(sts) {
var canSplit = true; var canSplit = true;
for(var k = j + 1; k < uri.length; k++) { for(var k = j + 1; k < uri.length; k++) {
if(__Serializer.prototype._notNameChars.indexOf(uri[k]) >= 0) { if(__Serializer.prototype._notNameChars.indexOf(uri[k]) >= 0) {
canSplit = false; break; canSplit = false;
break;
} }
} }
if(canSplit) { if(canSplit) {
var localid = uri.slice(j + 1); var localid = uri.slice(j + 1);
var namesp = uri.slice(0, j + 1); var namesp = uri.slice(0, j + 1);
if (sz.defaultNamespace && sz.defaultNamespace == namesp if(sz.defaultNamespace
&& sz.defaultNamespace == namesp
&& sz.flags.indexOf('d') < 0) { // d -> suppress default && sz.flags.indexOf('d') < 0) { // d -> suppress default
if (sz.flags.indexOf('k') >= 0 && if(sz.flags.indexOf('k') >= 0
sz.keyords.indexOf(localid) <0) && sz.keyords.indexOf(localid) < 0)
return localid; return localid;
return ':' + localid; return ':' + localid;
} }
@ -379,7 +483,7 @@ __Serializer.prototype.statementsToN3 = function(sts) {
} }
} }
if(sz.flags.indexOf('r') < 0 && sz.base) if(sz.flags.indexOf('r') < 0 && sz.base)
uri = Util.uri.refTo(sz.base, uri); uri = $rdf.Util.uri.refTo(sz.base, uri);
else if(sz.flags.indexOf('u') >= 0) else if(sz.flags.indexOf('u') >= 0)
uri = backslashUify(uri); uri = backslashUify(uri);
else uri = hexify(uri); else uri = hexify(uri);
@ -387,7 +491,7 @@ __Serializer.prototype.statementsToN3 = function(sts) {
} }
function prefixDirectives() { function prefixDirectives() {
str = ''; var str = '';
if(sz.defaultNamespace) if(sz.defaultNamespace)
str += '@prefix : <' + sz.defaultNamespace + '>.\n'; str += '@prefix : <' + sz.defaultNamespace + '>.\n';
for(var ns in namespaceCounts) { for(var ns in namespaceCounts) {
@ -400,6 +504,7 @@ __Serializer.prototype.statementsToN3 = function(sts) {
// //
var forbidden1 = new RegExp(/[\\"\b\f\r\v\t\n\u0080-\uffff]/gm); var forbidden1 = new RegExp(/[\\"\b\f\r\v\t\n\u0080-\uffff]/gm);
var forbidden3 = new RegExp(/[\\"\b\f\r\v\u0080-\uffff]/gm); var forbidden3 = new RegExp(/[\\"\b\f\r\v\u0080-\uffff]/gm);
function stringToN3(str, flags) { function stringToN3(str, flags) {
if(!flags) flags = "e"; if(!flags) flags = "e";
var res = '', i = 0, j = 0; var res = '', i = 0, j = 0;
@ -430,8 +535,7 @@ __Serializer.prototype.statementsToN3 = function(sts) {
res += "\\" + 'bfrtvn\\"' [k]; res += "\\" + 'bfrtvn\\"' [k];
} else { } else {
if(flags.indexOf('e') >= 0) { if(flags.indexOf('e') >= 0) {
res += '\\u' + ('000'+ res += '\\u' + ('000' + ch.charCodeAt(0).toString(16).toLowerCase()).slice(-4)
ch.charCodeAt(0).toString(16).toLowerCase()).slice(-4)
} else { // no 'e' flag } else { // no 'e' flag
res += ch; res += ch;
} }
@ -443,14 +547,12 @@ __Serializer.prototype.statementsToN3 = function(sts) {
} }
// Body of toN3: // Body of toN3:
var tree = statementListToTree(sts); var tree = statementListToTree(sts);
return prefixDirectives() + treeToString(tree, -1); return prefixDirectives() + treeToString(tree, -1);
} }
// String ecaping utilities // String ecaping utilities
function hexify(str) { // also used in parser function hexify(str) { // also used in parser
// var res = ''; // var res = '';
// for (var i=0; i<str.length; i++) { // for (var i=0; i<str.length; i++) {
@ -466,7 +568,7 @@ function hexify(str) { // also used in parser
function backslashUify(str) { function backslashUify(str) {
var res = ''; var res = '', k;
for(var i = 0; i < str.length; i++) { for(var i = 0; i < str.length; i++) {
k = str.charCodeAt(i); k = str.charCodeAt(i);
if(k > 65535) if(k > 65535)
@ -485,25 +587,22 @@ function backslashUify(str) {
//////////////////////////////////////////////// XML serialization //////////////////////////////////////////////// XML serialization
__Serializer.prototype.statementsToXML = function (sts) { __Serializer.prototype.statementsToXML = function (sts) {
var indent = 4; var indent = 4;
var width = 80; var width = 80;
// var subjects = null; // set later
var sz = this; var sz = this;
var namespaceCounts = []; // which have been used var namespaceCounts = []; // which have been used
namespaceCounts['http://www.w3.org/1999/02/22-rdf-syntax-ns#'] = true; namespaceCounts['http://www.w3.org/1999/02/22-rdf-syntax-ns#'] = true;
////////////////////////// Arrange the bits of XML text ////////////////////////// Arrange the bits of XML text
var spaces = function (n) { var spaces = function (n) {
var s = ''; var s = '';
for(var i = 0; i < n; i++) s += ' '; for(var i = 0; i < n; i++) s += ' ';
return s return s
} }
XMLtreeToLine = function(tree) { var XMLtreeToLine = function (tree) {
var str = ''; var str = '';
for(var i = 0; i < tree.length; i++) { for(var i = 0; i < tree.length; i++) {
var branch = tree[i]; var branch = tree[i];
@ -514,7 +613,7 @@ __Serializer.prototype.statementsToXML = function(sts) {
} }
// Convert a nested tree of lists and strings to a string // Convert a nested tree of lists and strings to a string
XMLtreeToString = function(tree, level) { var XMLtreeToString = function (tree, level) {
var str = ''; var str = '';
var lastLength = 100000; var lastLength = 100000;
if(!level) level = 0; if(!level) level = 0;
@ -522,9 +621,9 @@ __Serializer.prototype.statementsToXML = function(sts) {
var branch = tree[i]; var branch = tree[i];
if(typeof branch != 'string') { if(typeof branch != 'string') {
var substr = XMLtreeToString(branch, level + 1); var substr = XMLtreeToString(branch, level + 1);
if ( if(substr.length < 10 * (width - indent * level)
substr.length < 10*(width-indent*level) && substr.indexOf('"""') < 0) {
&& substr.indexOf('"""') < 0) {// Don't mess up multiline strings // Don't mess up multiline strings
var line = XMLtreeToLine(branch); var line = XMLtreeToLine(branch);
if(line.length < (width - indent * level)) { if(line.length < (width - indent * level)) {
branch = ' ' + line; // @@ Hack: treat as string below branch = ' ' + line; // @@ Hack: treat as string below
@ -552,14 +651,12 @@ __Serializer.prototype.statementsToXML = function(sts) {
function statementListToXMLTree(statements) { function statementListToXMLTree(statements) {
sz.suggestPrefix('rdf', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'); sz.suggestPrefix('rdf', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#');
var res = []; var stats = sz.rootSubjects(statements);
var pair = sz.rootSubjects(statements); var roots = stats.roots;
var roots = pair[0]; var results = [], root;
var subjects = pair[1];
results = []
for(var i = 0; i < roots.length; i++) { for(var i = 0; i < roots.length; i++) {
root = roots[i]; root = roots[i];
results.push(subjectXMLTree(root, subjects)) results.push(subjectXMLTree(root, stats))
} }
return results; return results;
} }
@ -570,17 +667,15 @@ __Serializer.prototype.statementsToXML = function(sts) {
} }
function relURI(term) { function relURI(term) {
return escapeForXML((sz.base) ? Util.uri.refTo(this.base, term.uri) : term.uri); return escapeForXML((sz.base) ? $rdf.Util.uri.refTo(this.base, term.uri) : term.uri);
} }
// The tree for a subject // The tree for a subject
function subjectXMLTree(subject, subjects, referenced) { function subjectXMLTree(subject, stats) {
const liPrefix = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#_'; const liPrefix = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#_';
var results = [];
var type = null; var type = null, t, st;
var sts = stats.subjects[sz.toStr(subject)]; // relevant statements
var results = []
var sts = subjects[sz.toStr(subject)]; // relevant statements
// Sort only on the predicate, leave the order at object // Sort only on the predicate, leave the order at object
// level undisturbed. This leaves multilingual content in // level undisturbed. This leaves multilingual content in
// the order of entry (for partner literals), which helps // the order of entry (for partner literals), which helps
@ -598,20 +693,18 @@ __Serializer.prototype.statementsToXML = function(sts) {
return 1; return 1;
} else if(aa[0] < bb[0]) { } else if(aa[0] < bb[0]) {
return -1; return -1;
} else { } else if("undefined" !== typeof aa[1] && "undefined" !== typeof bb[1]) {
if ("undefined" !== typeof aa[1] && "undefined" !== typeof bb[1]) {
if(parseInt(aa[1], 10) > parseInt(bb[1], 10)) { if(parseInt(aa[1], 10) > parseInt(bb[1], 10)) {
return 1; return 1;
} else if(parseInt(aa[1], 10) < parseInt(bb[1], 10)) { } else if(parseInt(aa[1], 10) < parseInt(bb[1], 10)) {
return -1; return -1;
} }
} }
}
return 0; return 0;
}); });
for (var i=0; i<sts.length; i++) {
var st = sts[i];
for(var i = 0; i < sts.length; i++) {
st = sts[i];
if(st.predicate.uri == 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' && !type && st.object.termType == "symbol") { if(st.predicate.uri == 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' && !type && st.object.termType == "symbol") {
// look for a type // look for a type
type = st.object; type = st.object;
@ -619,55 +712,53 @@ __Serializer.prototype.statementsToXML = function(sts) {
// see whether predicate can be replaced with "li" // see whether predicate can be replaced with "li"
if(st.predicate.uri.substr(0, liPrefix.length) == liPrefix) { if(st.predicate.uri.substr(0, liPrefix.length) == liPrefix) {
var number = st.predicate.uri.substr(liPrefix.length); var number = st.predicate.uri.substr(liPrefix.length);
// make sure these are actually numeric list items // make sure these are actually numeric list items
var intNumber = parseInt(number); var intNumber = parseInt(number);
if(number == intNumber.toString()) { if(number == intNumber.toString()) {
// was numeric; don't need to worry about ordering since we've already // was numeric; don't need to worry about ordering since we've already
// sorted the statements // sorted the statements
st.predicate = RDFSymbol('http://www.w3.org/1999/02/22-rdf-syntax-ns#li'); st.predicate = $rdf.Symbol('http://www.w3.org/1999/02/22-rdf-syntax-ns#li');
} }
} }
t = qname(st.predicate);
switch(st.object.termType) { switch(st.object.termType) {
case 'bnode': case 'bnode':
if(sz.incoming[st.object].length == 1) { if(sz.incoming[st.object].length == 1) {
results = results.concat(['<'+qname(st.predicate)+'>', results = results.concat(['<' + t + '>',
subjectXMLTree(st.object, subjects, true), subjectXMLTree(st.object, stats),
'</'+qname(st.predicate)+'>']); '</' + t + '>']);
} else { } else {
results = results.concat(['<'+qname(st.predicate)+' rdf:nodeID="' results = results.concat(['<' + t + ' rdf:nodeID="'
+ st.object.toNT().slice(2) + '"/>']); + st.object.toNT().slice(2) + '"/>']);
} }
break; break;
case 'symbol': case 'symbol':
results = results.concat(['<'+qname(st.predicate)+' rdf:resource="' results = results.concat(['<' + t + ' rdf:resource="'
+ relURI(st.object) + '"/>']); + relURI(st.object) + '"/>']);
break; break;
case 'literal': case 'literal':
results = results.concat(['<'+qname(st.predicate) results = results.concat(['<' + t
+ (st.object.dt ? ' rdf:datatype="' + escapeForXML(st.object.dt.uri) + '"' : '') + (st.object.dt ? ' rdf:datatype="' + escapeForXML(st.object.dt.uri) + '"' : '')
+ (st.object.lang ? ' xml:lang="' + st.object.lang + '"' : '') + (st.object.lang ? ' xml:lang="' + st.object.lang + '"' : '')
+ '>' + escapeForXML(st.object.value) + '>' + escapeForXML(st.object.value)
+ '</'+qname(st.predicate)+'>']); + '</' + t + '>']);
break; break;
case 'collection': case 'collection':
results = results.concat(['<'+qname(st.predicate)+' rdf:parseType="Collection">', results = results.concat(['<' + t + ' rdf:parseType="Collection">',
collectionXMLTree(st.object, subjects), collectionXMLTree(st.object, stats),
'</'+qname(st.predicate)+'>']); '</' + t + '>']);
break; break;
default: default:
throw "Can't serialize object of type " + st.object.termType + " into XML"; throw "Can't serialize object of type " + st.object.termType + " into XML";
} // switch } // switch
} }
} }
var tag = type ? qname(type) : 'rdf:Description'; var tag = type ? qname(type) : 'rdf:Description';
attrs = ''; var attrs = '';
if(subject.termType == 'bnode') { if(subject.termType == 'bnode') {
if(!referenced || sz.incoming[subject].length != 1) { // not an anonymous bnode if(sz.incoming[subject].length != 1) { // not an anonymous bnode
attrs = ' rdf:nodeID="' + subject.toNT().slice(2) + '"'; attrs = ' rdf:nodeID="' + subject.toNT().slice(2) + '"';
} }
} else { } else {
@ -677,14 +768,57 @@ __Serializer.prototype.statementsToXML = function(sts) {
return ['<' + tag + attrs + '>'].concat([results]).concat(["</" + tag + ">"]); return ['<' + tag + attrs + '>'].concat([results]).concat(["</" + tag + ">"]);
} }
function collectionXMLTree(subject, subjects) { function collectionXMLTree(subject, stats) {
res = [] var res = []
for(var i = 0; i < subject.elements.length; i++) { for(var i = 0; i < subject.elements.length; i++) {
res.push(subjectXMLTree(subject.elements[i], subjects)); res.push(subjectXMLTree(subject.elements[i], stats));
} }
return res; return res;
} }
// The property tree for a single subject or anonymos node
function propertyXMLTree(subject, stats) {
var results = []
var sts = stats.subjects[sz.toStr(subject)]; // relevant statements
if(sts == undefined) return results; // No relevant statements
sts.sort();
for(var i = 0; i < sts.length; i++) {
var st = sts[i];
switch(st.object.termType) {
case 'bnode':
if(stats.rootsHash[st.object.toNT()]) { // This bnode has been done as a root -- no content here @@ what bout first time
results = results.concat(['<' + qname(st.predicate) + ' rdf:nodeID="' + st.object.toNT().slice(2) + '">',
'</' + qname(st.predicate) + '>']);
} else {
results = results.concat(['<' + qname(st.predicate) + ' rdf:parseType="Resource">',
propertyXMLTree(st.object, stats),
'</' + qname(st.predicate) + '>']);
}
break;
case 'symbol':
results = results.concat(['<' + qname(st.predicate) + ' rdf:resource="'
+ relURI(st.object) + '"/>']);
break;
case 'literal':
results = results.concat(['<' + qname(st.predicate)
+ (st.object.datatype ? ' rdf:datatype="' + escapeForXML(st.object.datatype.uri) + '"' : '')
+ (st.object.lang ? ' xml:lang="' + st.object.lang + '"' : '')
+ '>' + escapeForXML(st.object.value)
+ '</' + qname(st.predicate) + '>']);
break;
case 'collection':
results = results.concat(['<' + qname(st.predicate) + ' rdf:parseType="Collection">',
collectionXMLTree(st.object, stats),
'</' + qname(st.predicate) + '>']);
break;
default:
throw "Can't serialize object of type " + st.object.termType + " into XML";
} // switch
}
return results;
}
function qname(term) { function qname(term) {
var uri = term.uri; var uri = term.uri;
@ -702,7 +836,8 @@ __Serializer.prototype.statementsToXML = function(sts) {
} }
var localid = uri.slice(j + 1); var localid = uri.slice(j + 1);
var namesp = uri.slice(0, j + 1); var namesp = uri.slice(0, j + 1);
if (sz.defaultNamespace && sz.defaultNamespace == namesp if(sz.defaultNamespace
&& sz.defaultNamespace == namesp
&& sz.flags.indexOf('d') < 0) { // d -> suppress default && sz.flags.indexOf('d') < 0) { // d -> suppress default
return localid; return localid;
} }
@ -714,7 +849,6 @@ __Serializer.prototype.statementsToXML = function(sts) {
} }
// Body of toXML: // Body of toXML:
var tree = statementListToXMLTree(sts); var tree = statementListToXMLTree(sts);
var str = '<rdf:RDF'; var str = '<rdf:RDF';
if(sz.defaultNamespace) if(sz.defaultNamespace)
@ -729,4 +863,6 @@ __Serializer.prototype.statementsToXML = function(sts) {
} // End @@ body } // End @@ body
return Serializer;
}();

397
chrome/content/zotero/xpcom/rdf/term.js
View File

@ -7,225 +7,244 @@
// //
// W3C open source licence 2005. // W3C open source licence 2005.
// //
RDFTracking = 0 // Are we requiring reasons for statements?
//takes in an object and makes it an object if it's a literal
function makeTerm(val) {
// tabulator.log.debug("Making term from " + val)
if (typeof val == 'object') return val;
if (typeof val == 'string') return new RDFLiteral(val);
if (typeof val == 'number') return new RDFLiteral(val); // @@ differet types
if (typeof val == 'boolean') return new RDFLiteral(val?"1":"0", undefined,
RDFSymbol.prototype.XSDboolean);
if (typeof val == 'undefined') return undefined;
alert("Can't make term from " + val + " of type " + typeof val);
}
// Symbol // Symbol
$rdf.Empty = function () {
return this;
};
function RDFEmpty() { $rdf.Empty.prototype.termType = 'empty';
$rdf.Empty.prototype.toString = function () {
return "()"
};
$rdf.Empty.prototype.toNT = $rdf.Empty.prototype.toString;
$rdf.Symbol = function (uri) {
this.uri = uri;
this.value = uri; // -- why? -tim
return this; return this;
} }
RDFEmpty.prototype.termType = 'empty'
RDFEmpty.prototype.toString = function () { return "()" }
RDFEmpty.prototype.toNT = function () { return "@@" }
function RDFSymbol_toNT(x) {
return ("<" + x.uri + ">")
}
function toNT() {
return RDFSymbol_toNT(this)
}
function RDFSymbol(uri) {
this.uri = uri
return this
}
RDFSymbol.prototype.termType = 'symbol'
RDFSymbol.prototype.toString = toNT
RDFSymbol.prototype.toNT = toNT
// Some precalculaued symbols
RDFSymbol.prototype.XSDboolean = new RDFSymbol('http://www.w3.org/2001/XMLSchema#boolean');
RDFSymbol.prototype.integer = new RDFSymbol('http://www.w3.org/2001/XMLSchema#integer');
$rdf.Symbol.prototype.termType = 'symbol';
$rdf.Symbol.prototype.toString = function () {
return("<" + this.uri + ">");
};
$rdf.Symbol.prototype.toNT = $rdf.Symbol.prototype.toString;
// Some precalculated symbols
$rdf.Symbol.prototype.XSDboolean = new $rdf.Symbol('http://www.w3.org/2001/XMLSchema#boolean');
$rdf.Symbol.prototype.XSDdecimal = new $rdf.Symbol('http://www.w3.org/2001/XMLSchema#decimal');
$rdf.Symbol.prototype.XSDfloat = new $rdf.Symbol('http://www.w3.org/2001/XMLSchema#float');
$rdf.Symbol.prototype.XSDinteger = new $rdf.Symbol('http://www.w3.org/2001/XMLSchema#integer');
$rdf.Symbol.prototype.XSDdateTime = new $rdf.Symbol('http://www.w3.org/2001/XMLSchema#dateTime');
$rdf.Symbol.prototype.integer = new $rdf.Symbol('http://www.w3.org/2001/XMLSchema#integer'); // Used?
// Blank Node // Blank Node
if(typeof $rdf.NextId != 'undefined') {
$rdf.log.error('Attempt to re-zero existing blank node id counter at ' + $rdf.NextId);
} else {
$rdf.NextId = 0; // Global genid
}
$rdf.NTAnonymousNodePrefix = "_:n";
var RDFNextId = 0; // Gobal genid $rdf.BlankNode = function (id) {
RDFGenidPrefix = "genid:"
NTAnonymousNodePrefix = "_:n"
function RDFBlankNode(id) {
/*if (id) /*if (id)
this.id = id; this.id = id;
else*/ else*/
this.id = RDFNextId++ this.id = $rdf.NextId++;
this.value = id ? id : this.id.toString();
return this return this
} };
RDFBlankNode.prototype.termType = 'bnode' $rdf.BlankNode.prototype.termType = 'bnode';
$rdf.BlankNode.prototype.toNT = function () {
RDFBlankNode.prototype.toNT = function() { return $rdf.NTAnonymousNodePrefix + this.id
return NTAnonymousNodePrefix + this.id };
} $rdf.BlankNode.prototype.toString = $rdf.BlankNode.prototype.toNT;
RDFBlankNode.prototype.toString = RDFBlankNode.prototype.toNT
// Literal // Literal
$rdf.Literal = function (value, lang, datatype) {
function RDFLiteral(value, lang, datatype) {
this.value = value this.value = value
this.lang=lang; // string if(lang == "" || lang == null) this.lang = undefined;
this.datatype=datatype; // term else this.lang = lang; // string
this.toString = RDFLiteralToString if(datatype == null) this.datatype = undefined;
this.toNT = RDFLiteral_toNT else this.datatype = datatype; // term
return this return this;
} }
RDFLiteral.prototype.termType = 'literal' $rdf.Literal.prototype.termType = 'literal'
$rdf.Literal.prototype.toString = function () {
function RDFLiteral_toNT() { return '' + this.value;
};
$rdf.Literal.prototype.toNT = function () {
var str = this.value var str = this.value
if(typeof str != 'string') { if(typeof str != 'string') {
if(typeof str == 'number') return '' + str; if(typeof str == 'number') return '' + str;
throw Error("Value of RDF literal is not string: " + str) throw Error("Value of RDF literal is not string: " + str)
} }
str = str.replace(/\\/g, '\\\\'); // escape str = str.replace(/\\/g, '\\\\'); // escape backslashes
str = str.replace(/\"/g, '\\"'); str = str.replace(/\"/g, '\\"'); // escape quotes
str = '"' + str + '"' //' str = str.replace(/\n/g, '\\n'); // escape newlines
str = '"' + str + '"' //';
if(this.datatype) { if(this.datatype) {
str = str + '^^' + this.datatype//.toNT() str = str + '^^' + this.datatype.toNT()
} }
if(this.lang) { if(this.lang) {
str = str + "@" + this.lang str = str + "@" + this.lang;
}
return str
} }
return str;
};
function RDFLiteralToString() { $rdf.Collection = function () {
return ''+this.value this.id = $rdf.NextId++; // Why need an id? For hashstring.
} this.elements = [];
this.closed = false;
};
RDFLiteral.prototype.toString = RDFLiteralToString $rdf.Collection.prototype.termType = 'collection';
RDFLiteral.prototype.toNT = RDFLiteral_toNT
function RDFCollection() { $rdf.Collection.prototype.toNT = function () {
this.id = RDFNextId++ return $rdf.NTAnonymousNodePrefix + this.id
this.elements = [] };
this.closed = false
}
RDFCollection.prototype.termType = 'collection' $rdf.Collection.prototype.toString = function () {
var str = '(';
for(var i = 0; i < this.elements.length; i++)
str += this.elements[i] + ' ';
return str + ')';
};
RDFCollection.prototype.toNT = function() { $rdf.Collection.prototype.append = function (el) {
return NTAnonymousNodePrefix + this.id
}
RDFCollection.prototype.toString = RDFCollection.prototype.toNT
RDFCollection.prototype.append = function (el) {
this.elements.push(el) this.elements.push(el)
} }
RDFCollection.prototype.unshift=function(el){ $rdf.Collection.prototype.unshift = function (el) {
this.elements.unshift(el); this.elements.unshift(el);
} }
RDFCollection.prototype.shift=function(){ $rdf.Collection.prototype.shift = function () {
return this.elements.shift(); return this.elements.shift();
} }
RDFCollection.prototype.close = function () { $rdf.Collection.prototype.close = function () {
this.closed = true this.closed = true
} }
// Convert Javascript representation to RDF term object
//
$rdf.term = function (val) {
if(typeof val == 'object')
if(val instanceof Date) {
var d2 = function (x) {
return('' + (100 + x)).slice(1, 3)
}; // format as just two digits
return new $rdf.Literal('' + val.getUTCFullYear() + '-' + d2(val.getUTCMonth() + 1)
+ '-' + d2(val.getUTCDate()) + 'T' + d2(val.getUTCHours()) + ':'
+ d2(val.getUTCMinutes()) + ':' + d2(val.getUTCSeconds()) + 'Z',
undefined,
$rdf.Symbol.prototype.XSDdateTime);
} else if(val instanceof Array) {
var x = new $rdf.Collection();
for(var i = 0; i < val.length; i++)
x.append($rdf.term(val[i]));
return x;
} else
return val;
if(typeof val == 'string')
return new $rdf.Literal(val);
if(typeof val == 'number') {
var dt;
if(('' + val).indexOf('e') >= 0) dt = $rdf.Symbol.prototype.XSDfloat;
else if(('' + val).indexOf('.') >= 0) dt = $rdf.Symbol.prototype.XSDdecimal;
else dt = $rdf.Symbol.prototype.XSDinteger;
return new $rdf.Literal(val, undefined, dt);
}
if(typeof val == 'boolean')
return new $rdf.Literal(val ? "1" : "0", undefined, $rdf.Symbol.prototype.XSDboolean);
if(typeof val == 'undefined')
return undefined;
throw("Can't make term from " + val + " of type " + typeof val);
}
// Statement // Statement
// //
// This is a triple with an optional reason. // This is a triple with an optional reason.
// //
// The reason can point to provenece or inference // The reason can point to provenece or inference
// //
function RDFStatement_toNT() { $rdf.Statement = function (subject, predicate, object, why) {
return (this.subject.toNT() + " " this.subject = $rdf.term(subject)
+ this.predicate.toNT() + " " this.predicate = $rdf.term(predicate)
+ this.object.toNT() +" .") this.object = $rdf.term(object)
}
function RDFStatement(subject, predicate, object, why) {
this.subject = makeTerm(subject)
this.predicate = makeTerm(predicate)
this.object = makeTerm(object)
if(typeof why != 'undefined') { if(typeof why != 'undefined') {
this.why = why this.why = why;
} else if (RDFTracking) {
tabulator.log.debug("WARNING: No reason on "+subject+" "+predicate+" "+object)
} }
return this return this;
} }
RDFStatement.prototype.toNT = RDFStatement_toNT $rdf.st = function (subject, predicate, object, why) {
RDFStatement.prototype.toString = RDFStatement_toNT return new $rdf.Statement(subject, predicate, object, why);
};
$rdf.Statement.prototype.toNT = function () {
return (this.subject.toNT() + " " + this.predicate.toNT() + " " + this.object.toNT() + " .");
};
$rdf.Statement.prototype.toString = $rdf.Statement.prototype.toNT;
// Formula // Formula
// //
// Set of statements. // Set of statements.
$rdf.Formula = function () {
function RDFFormula() {
this.statements = [] this.statements = []
this.constraints = [] this.constraints = []
this.initBindings = [] this.initBindings = []
this.optional = [] this.optional = []
this.superFormula = null; return this;
return this };
}
function RDFFormula_toNT() {
// throw 'Who called me?'; $rdf.Formula.prototype.termType = 'formula';
$rdf.Formula.prototype.toNT = function () {
return "{" + this.statements.join('\n') + "}" return "{" + this.statements.join('\n') + "}"
} };
$rdf.Formula.prototype.toString = $rdf.Formula.prototype.toNT;
//RDFQueryFormula.prototype = new RDFFormula() $rdf.Formula.prototype.add = function (subj, pred, obj, why) {
//RDFQueryFormula.termType = 'queryFormula' this.statements.push(new $rdf.Statement(subj, pred, obj, why))
RDFFormula.prototype.termType = 'formula'
RDFFormula.prototype.toNT = RDFFormula_toNT
RDFFormula.prototype.toString = RDFFormula_toNT
RDFFormula.prototype.add = function(subj, pred, obj, why) {
this.statements.push(new RDFStatement(subj, pred, obj, why))
} }
// Convenience methods on a formula allow the creation of new RDF terms: // Convenience methods on a formula allow the creation of new RDF terms:
$rdf.Formula.prototype.sym = function (uri, name) {
RDFFormula.prototype.sym = function(uri,name) {
if(name != null) { if(name != null) {
if (!tabulator.ns[uri]) throw 'The prefix "'+uri+'" is not set in the API'; throw "This feature (kb.sym with 2 args) is removed. Do not assume prefix mappings."
uri = tabulator.ns[uri] + name if(!$rdf.ns[uri]) throw 'The prefix "' + uri + '" is not set in the API';
uri = $rdf.ns[uri] + name
} }
return new RDFSymbol(uri) return new $rdf.Symbol(uri)
} }
RDFFormula.prototype.literal = function(val, lang, dt) { $rdf.sym = function (uri) {
return new RDFLiteral(val.toString(), lang, dt) return new $rdf.Symbol(uri);
};
$rdf.Formula.prototype.literal = function (val, lang, dt) {
return new $rdf.Literal(val.toString(), lang, dt)
}
$rdf.lit = $rdf.Formula.prototype.literal;
$rdf.Formula.prototype.bnode = function (id) {
return new $rdf.BlankNode(id)
} }
RDFFormula.prototype.bnode = function(id) { $rdf.Formula.prototype.formula = function () {
return new RDFBlankNode(id) return new $rdf.Formula()
} }
RDFFormula.prototype.formula = function() { $rdf.Formula.prototype.collection = function () { // obsolete
return new RDFFormula() return new $rdf.Collection()
} }
RDFFormula.prototype.collection = function () { // obsolete $rdf.Formula.prototype.list = function (values) {
return new RDFCollection() var li = new $rdf.Collection();
}
RDFFormula.prototype.list = function (values) {
li = new RDFCollection();
if(values) { if(values) {
for(var i = 0; i < values.length; i++) { for(var i = 0; i < values.length; i++) {
li.append(values[i]); li.append(values[i]);
@ -234,58 +253,50 @@ RDFFormula.prototype.list = function (values) {
return li; return li;
} }
RDFFormula.instances={};
RDFFormula.prototype.registerFormula = function(accesskey){
var superFormula = this.superFormula || this;
RDFFormula.instances[accesskey] = this;
var formulaTerm = superFormula.bnode();
superFormula.add(formulaTerm, tabulator.ns.rdf('type'),superFormula.sym("http://www.w3.org/2000/10/swap/log#Formula"));
superFormula.add(formulaTerm, tabulator.ns.foaf('name'), superFormula.literal(accesskey));
superFormula.add(formulaTerm, tabulator.ns.link('accesskey'), superFormula.literal(accesskey));
//RDFFormula.instances.push("accesskey");
}
/* Variable /* Variable
** **
** Variables are placeholders used in patterns to be matched. ** Variables are placeholders used in patterns to be matched.
** In cwm they are symbols which are the formula's list of quantified variables. ** In cwm they are symbols which are the formula's list of quantified variables.
** In sparl they are not visibily URIs. Here we compromise, by having ** In sparl they are not visibily URIs. Here we compromise, by having
** a common special base URI for variables. ** a common special base URI for variables. Their names are uris,
** but the ? nottaion has an implicit base uri of 'varid:'
*/ */
RDFVariableBase = "varid:"; // We deem variabe x to be the symbol varid:x $rdf.Variable = function (rel) {
this.base = "varid:"; // We deem variabe x to be the symbol varid:x
function RDFVariable(rel) { this.uri = $rdf.Util.uri.join(rel, this.base);
this.uri = URIjoin(rel, RDFVariableBase);
return this; return this;
} }
RDFVariable.prototype.termType = 'variable'; $rdf.Variable.prototype.termType = 'variable';
RDFVariable.prototype.toNT = function() { $rdf.Variable.prototype.toNT = function () {
if (this.uri.slice(0, RDFVariableBase.length) == RDFVariableBase) { if(this.uri.slice(0, this.base.length) == this.base) {
return '?'+ this.uri.slice(RDFVariableBase.length);} // @@ poor man's refTo return '?' + this.uri.slice(this.base.length);
} // @@ poor man's refTo
return '?' + this.uri; return '?' + this.uri;
}; };
RDFVariable.prototype.toString = RDFVariable.prototype.toNT; $rdf.Variable.prototype.toString = $rdf.Variable.prototype.toNT;
RDFVariable.prototype.classOrder = 7; $rdf.Variable.prototype.classOrder = 7;
RDFFormula.prototype.variable = function(name) { $rdf.variable = $rdf.Formula.prototype.variable = function (name) {
return new RDFVariable(name); return new $rdf.Variable(name);
}; };
RDFVariable.prototype.hashString = RDFVariable.prototype.toNT; $rdf.Variable.prototype.hashString = $rdf.Variable.prototype.toNT;
// The namespace function generator // The namespace function generator
$rdf.Namespace = function (nsuri) {
function RDFNamespace(nsuri) { return function (ln) {
return function(ln) { return new RDFSymbol(nsuri+(ln===undefined?'':ln)) } return new $rdf.Symbol(nsuri + (ln === undefined ? '' : ln))
}
} }
RDFFormula.prototype.ns = function(nsuri) { $rdf.Formula.prototype.ns = function (nsuri) {
return function(ln) { return new RDFSymbol(nsuri+(ln===undefined?'':ln)) } return function (ln) {
return new $rdf.Symbol(nsuri + (ln === undefined ? '' : ln))
}
} }
@ -293,21 +304,43 @@ RDFFormula.prototype.ns = function(nsuri) {
// //
// The bnode bit should not be used on program-external values; designed // The bnode bit should not be used on program-external values; designed
// for internal work such as storing a bnode id in an HTML attribute. // for internal work such as storing a bnode id in an HTML attribute.
// Not coded for literals. // This will only parse the strings generated by the vaious toNT() methods.
$rdf.Formula.prototype.fromNT = function (str) {
RDFFormula.prototype.fromNT = function(str) {
var len = str.length var len = str.length
var ch = str.slice(0, 1) var ch = str.slice(0, 1)
if (ch == '<') return this.sym(str.slice(1,len-1)) if(ch == '<') return $rdf.sym(str.slice(1, len - 1))
if(ch == '"') {
var lang = undefined;
var dt = undefined;
var k = str.lastIndexOf('"');
if(k < len - 1) {
if(str[k + 1] == '@') lang = str.slice(k + 2, len);
else if(str.slice(k + 1, k + 3) == '^^') dt = $rdf.fromNT(str.slice(k + 3, len));
else throw "Can't convert string from NT: " + str
}
var str = (str.slice(1, k));
str = str.replace(/\\"/g, '"'); // unescape quotes '
str = str.replace(/\\n/g, '\n'); // unescape newlines
str = str.replace(/\\\\/g, '\\'); // unescape backslashes
return $rdf.lit(str, lang, dt);
}
if(ch == '_') { if(ch == '_') {
var x = new RDFBlankNode(); var x = new $rdf.BlankNode();
x.id = parseInt(str.slice(3)); x.id = parseInt(str.slice(3));
RDFNextId-- $rdf.NextId--
return x return x
} }
throw "Can't convert from NT"+str; if(ch == '?') {
var x = new $rdf.Variable(str.slice(1));
//alert("Can't yet convert from NT: '"+str+"', "+str[0]) return x;
} }
throw "Can't convert from NT: " + str;
}
$rdf.fromNT = $rdf.Formula.prototype.fromNT; // Not for inexpert user
// Convenience - and more conventional name:
$rdf.graph = function () {
return new $rdf.IndexedFormula();
};
// ends // ends

66
chrome/content/zotero/xpcom/rdf/uri.js
View File

@ -11,12 +11,12 @@
// //
// See also http://www.w3.org/2000/10/swap/uripath.py // See also http://www.w3.org/2000/10/swap/uripath.py
// //
if(typeof $rdf.Util.uri == "undefined") {
$rdf.Util.uri = {};
};
if (typeof Util == "undefined") { Util = {}} $rdf.Util.uri.join = function (given, base) {
if (typeof Util.uri == "undefined") { Util.uri = {}} // if (typeof $rdf.log.debug != 'undefined') $rdf.log.debug(" URI given="+given+" base="+base)
Util.uri.join = function (given, base) {
// if (typeof tabulator.log.debug != 'undefined') tabulator.log.debug(" URI given="+given+" base="+base)
var baseHash = base.indexOf('#') var baseHash = base.indexOf('#')
if(baseHash > 0) base = base.slice(0, baseHash) if(baseHash > 0) base = base.slice(0, baseHash)
if(given.length == 0) return base // before chopping its filename off if(given.length == 0) return base // before chopping its filename off
@ -58,9 +58,9 @@ Util.uri.join = function (given, base) {
var path = base.slice(baseSingle) var path = base.slice(baseSingle)
var lastSlash = path.lastIndexOf("/") var lastSlash = path.lastIndexOf("/")
if(lastSlash < 0) return baseScheme + given if(lastSlash < 0) return baseScheme + given
if ((lastSlash >=0) && (lastSlash < (path.length-1))) if((lastSlash >= 0)
&& (lastSlash < (path.length - 1)))
path = path.slice(0, lastSlash + 1) // Chop trailing filename from base path = path.slice(0, lastSlash + 1) // Chop trailing filename from base
path = path + given path = path + given
while(path.match(/[^\/]*\/\.\.\//)) // must apply to result of prev while(path.match(/[^\/]*\/\.\.\//)) // must apply to result of prev
path = path.replace(/[^\/]*\/\.\.\//, '') // ECMAscript spec 7.8.5 path = path.replace(/[^\/]*\/\.\.\//, '') // ECMAscript spec 7.8.5
@ -69,35 +69,43 @@ Util.uri.join = function (given, base) {
return base.slice(0, baseSingle) + path return base.slice(0, baseSingle) + path
} }
var tIOService; if(typeof tabulator != 'undefined' && tabulator.isExtension) {
if (typeof( isExtension ) != "undefined" && isExtension) { $rdf.Util.uri.join2 = function (given, base) {
tIOService = Components.classes['@mozilla.org/network/io-service;1'] var tIOService = Components.classes['@mozilla.org/network/io-service;1']
.getService(Components.interfaces.nsIIOService); .getService(Components.interfaces.nsIIOService);
Util.uri.join2 = function (given, base){
var baseURI = tIOService.newURI(base, null, null); var baseURI = tIOService.newURI(base, null, null);
return tIOService.newURI(baseURI.resolve(given), null, null).spec; return tIOService.newURI(baseURI.resolve(given), null, null).spec;
} }
} else } else
Util.uri.join2 = Util.uri.join; $rdf.Util.uri.join2 = $rdf.Util.uri.join;
// refTo: Make a URI relative to a given base // refTo: Make a URI relative to a given base
// //
// based on code in http://www.w3.org/2000/10/swap/uripath.py // based on code in http://www.w3.org/2000/10/swap/uripath.py
// //
Util.uri.commonHost = new RegExp("^[-_a-zA-Z0-9.]+:(//[^/]*)?/[^/]*$"); $rdf.Util.uri.commonHost = new RegExp("^[-_a-zA-Z0-9.]+:(//[^/]*)?/[^/]*$");
Util.uri.refTo = function(base, uri) {
$rdf.Util.uri.hostpart = function (u) {
var m = /[^\/]*\/\/([^\/]*)\//.exec(u);
return m ? m[1] : ''
};
$rdf.Util.uri.refTo = function (base, uri) {
if(!base) return uri; if(!base) return uri;
if(base == uri) return ""; if(base == uri) return "";
var i = 0; // How much are they identical? var i = 0; // How much are they identical?
while(i < uri.length && i < base.length) while(i < uri.length && i < base.length)
if(uri[i] == base[i]) i++; if(uri[i] == base[i]) i++;
else break; else break;
if (base.slice(0,i).match(Util.uri.commonHost)) { if(base.slice(0, i).match($rdf.Util.uri.commonHost)) {
var k = uri.indexOf('//'); var k = uri.indexOf('//');
if(k < 0) k = -2; // no host if(k < 0) k = -2; // no host
var l = uri.indexOf('/', k + 2); // First *single* slash var l = uri.indexOf('/', k + 2); // First *single* slash
if (uri.slice(l+1, l+2) != '/' && base.slice(l+1, l+2) != '/' if(uri.slice(l + 1, l + 2) != '/'
&& uri.slice(0,l) == base.slice(0,l)) // common path to single slash && base.slice(l + 1, l + 2) != '/'
&& uri.slice(0, l) == base.slice(0, l))
// common path to single slash
return uri.slice(l); // but no other common path segments return uri.slice(l); // but no other common path segments
} }
// fragment of base? // fragment of base?
@ -105,7 +113,8 @@ Util.uri.refTo = function(base, uri) {
while(i > 0 && uri[i - 1] != '/') i--; while(i > 0 && uri[i - 1] != '/') i--;
if(i < 3) return uri; // No way if(i < 3) return uri; // No way
if ((base.indexOf('//', i-2) > 0) || uri.indexOf('//', i-2) > 0) if((base.indexOf('//', i - 2) > 0)
|| uri.indexOf('//', i - 2) > 0)
return uri; // an unshared '//' return uri; // an unshared '//'
if(base.indexOf(':', i) > 0) return uri; // unshared ':' if(base.indexOf(':', i) > 0) return uri; // unshared ':'
var n = 0; var n = 0;
@ -119,25 +128,22 @@ Util.uri.refTo = function(base, uri) {
/** returns URI without the frag **/ /** returns URI without the frag **/
Util.uri.docpart = function (uri) { $rdf.Util.uri.docpart = function (uri) {
var i = uri.indexOf("#") var i = uri.indexOf("#")
if(i < 0) return uri if(i < 0) return uri
return uri.slice(0, i) return uri.slice(0, i)
} }
/** The document in which something a thing defined **/
$rdf.Util.uri.document = function (x) {
return $rdf.sym($rdf.Util.uri.docpart(x.uri));
}
/** return the protocol of a uri **/ /** return the protocol of a uri **/
/** return null if there isn't one **/ /** return null if there isn't one **/
Util.uri.protocol = function (uri) { $rdf.Util.uri.protocol = function (uri) {
var index = uri.indexOf(':'); var index = uri.indexOf(':');
if (index >= 0) if(index >= 0) return uri.slice(0, index);
return uri.slice(0, index); else return null;
else
return null;
} //protocol } //protocol
URIjoin = Util.uri.join
uri_docpart = Util.uri.docpart
uri_protocol = Util.uri.protocol
//ends //ends

64
chrome/content/zotero/xpcom/translation/translate.js
View File

@ -2151,7 +2151,7 @@ Zotero.Translate.IO.String.prototype = {
"_initRDF":function(callback) { "_initRDF":function(callback) {
Zotero.debug("Translate: Initializing RDF data store"); Zotero.debug("Translate: Initializing RDF data store");
this._dataStore = new Zotero.RDF.AJAW.RDFIndexedFormula(); this._dataStore = new Zotero.RDF.AJAW.IndexedFormula();
this.RDF = new Zotero.Translate.IO._RDFSandbox(this._dataStore); this.RDF = new Zotero.Translate.IO._RDFSandbox(this._dataStore);
if(this.contentLength) { if(this.contentLength) {
@ -2262,9 +2262,9 @@ Zotero.Translate.IO.String.prototype = {
/** /**
* @class An API for handling RDF from the sandbox. This is exposed to translators as Zotero.RDF. * @class An API for handling RDF from the sandbox. This is exposed to translators as Zotero.RDF.
* *
* @property {Zotero.RDF.AJAW.RDFIndexedFormula} _dataStore * @property {Zotero.RDF.AJAW.IndexedFormula} _dataStore
* @property {Integer[]} _containerCounts * @property {Integer[]} _containerCounts
* @param {Zotero.RDF.AJAW.RDFIndexedFormula} dataStore * @param {Zotero.RDF.AJAW.IndexedFormula} dataStore
*/ */
Zotero.Translate.IO._RDFSandbox = function(dataStore) { Zotero.Translate.IO._RDFSandbox = function(dataStore) {
this._dataStore = dataStore; this._dataStore = dataStore;
@ -2289,12 +2289,12 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
}, },
/** /**
* Gets a resource as a Zotero.RDF.AJAW.RDFSymbol, rather than a string * Gets a resource as a Zotero.RDF.AJAW.Symbol, rather than a string
* @param {String|Zotero.RDF.AJAW.RDFSymbol} about * @param {String|Zotero.RDF.AJAW.Symbol} about
* @return {Zotero.RDF.AJAW.RDFSymbol} * @return {Zotero.RDF.AJAW.Symbol}
*/ */
"_getResource":function(about) { "_getResource":function(about) {
return (typeof about == "object" ? about : new Zotero.RDF.AJAW.RDFSymbol(about)); return (typeof about == "object" ? about : new Zotero.RDF.AJAW.Symbol(about));
}, },
/** /**
@ -2311,7 +2311,7 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
* Serializes the current RDF to a string * Serializes the current RDF to a string
*/ */
"serialize":function(dataMode) { "serialize":function(dataMode) {
var serializer = Serializer(); var serializer = Zotero.RDF.AJAW.Serializer(this._dataStore);
for(var prefix in this._dataStore.namespaces) { for(var prefix in this._dataStore.namespaces) {
serializer.suggestPrefix(prefix, this._dataStore.namespaces[prefix]); serializer.suggestPrefix(prefix, this._dataStore.namespaces[prefix]);
@ -2327,9 +2327,9 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Adds an RDF triple * Adds an RDF triple
* @param {String|Zotero.RDF.AJAW.RDFSymbol} about * @param {String|Zotero.RDF.AJAW.Symbol} about
* @param {String|Zotero.RDF.AJAW.RDFSymbol} relation * @param {String|Zotero.RDF.AJAW.Symbol} relation
* @param {String|Zotero.RDF.AJAW.RDFSymbol} value * @param {String|Zotero.RDF.AJAW.Symbol} value
* @param {Boolean} literal Whether value should be treated as a literal (true) or a resource * @param {Boolean} literal Whether value should be treated as a literal (true) or a resource
* (false) * (false)
*/ */
@ -2356,16 +2356,16 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Creates a new anonymous resource * Creates a new anonymous resource
* @return {Zotero.RDF.AJAW.RDFSymbol} * @return {Zotero.RDF.AJAW.Symbol}
*/ */
"newResource":function() { "newResource":function() {
return new Zotero.RDF.AJAW.RDFBlankNode(); return new Zotero.RDF.AJAW.BlankNode();
}, },
/** /**
* Creates a new container resource * Creates a new container resource
* @param {String} type The type of the container ("bag", "seq", or "alt") * @param {String} type The type of the container ("bag", "seq", or "alt")
* @param {String|Zotero.RDF.AJAW.RDFSymbol} about The URI of the resource * @param {String|Zotero.RDF.AJAW.Symbol} about The URI of the resource
* @return {Zotero.Translate.RDF.prototype.newContainer * @return {Zotero.Translate.RDF.prototype.newContainer
*/ */
"newContainer":function(type, about) { "newContainer":function(type, about) {
@ -2386,8 +2386,8 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Adds a new element to a container * Adds a new element to a container
* @param {String|Zotero.RDF.AJAW.RDFSymbol} about The container * @param {String|Zotero.RDF.AJAW.Symbol} about The container
* @param {String|Zotero.RDF.AJAW.RDFSymbol} element The element to add to the container * @param {String|Zotero.RDF.AJAW.Symbol} element The element to add to the container
* @param {Boolean} literal Whether element should be treated as a literal (true) or a resource * @param {Boolean} literal Whether element should be treated as a literal (true) or a resource
* (false) * (false)
*/ */
@ -2395,13 +2395,13 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
const rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"; const rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
var about = this._getResource(about); var about = this._getResource(about);
this._dataStore.add(about, new Zotero.RDF.AJAW.RDFSymbol(rdf+"_"+(this._containerCounts[about.toNT()]++)), element, literal); this._dataStore.add(about, new Zotero.RDF.AJAW.Symbol(rdf+"_"+(this._containerCounts[about.toNT()]++)), element, literal);
}, },
/** /**
* Gets all elements within a container * Gets all elements within a container
* @param {String|Zotero.RDF.AJAW.RDFSymbol} about The container * @param {String|Zotero.RDF.AJAW.Symbol} about The container
* @return {Zotero.RDF.AJAW.RDFSymbol[]} * @return {Zotero.RDF.AJAW.Symbol[]}
*/ */
"getContainerElements":function(about) { "getContainerElements":function(about) {
const liPrefix = "http://www.w3.org/1999/02/22-rdf-syntax-ns#_"; const liPrefix = "http://www.w3.org/1999/02/22-rdf-syntax-ns#_";
@ -2439,7 +2439,7 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Gets the URI a specific resource * Gets the URI a specific resource
* @param {String|Zotero.RDF.AJAW.RDFSymbol} resource * @param {String|Zotero.RDF.AJAW.Symbol} resource
* @return {String} * @return {String}
*/ */
"getResourceURI":function(resource) { "getResourceURI":function(resource) {
@ -2451,7 +2451,7 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Gets all resources in the RDF data store * Gets all resources in the RDF data store
* @return {Zotero.RDF.AJAW.RDFSymbol[]} * @return {Zotero.RDF.AJAW.Symbol[]}
*/ */
"getAllResources":function() { "getAllResources":function() {
var returnArray = []; var returnArray = [];
@ -2463,7 +2463,7 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Gets all arcs (predicates) into a resource * Gets all arcs (predicates) into a resource
* @return {Zotero.RDF.AJAW.RDFSymbol[]} * @return {Zotero.RDF.AJAW.Symbol[]}
* @deprecated Since 2.1. Use {@link Zotero.Translate.IO["rdf"]._RDFBase#getStatementsMatching} * @deprecated Since 2.1. Use {@link Zotero.Translate.IO["rdf"]._RDFBase#getStatementsMatching}
*/ */
"getArcsIn":function(resource) { "getArcsIn":function(resource) {
@ -2479,7 +2479,7 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Gets all arcs (predicates) out of a resource * Gets all arcs (predicates) out of a resource
* @return {Zotero.RDF.AJAW.RDFSymbol[]} * @return {Zotero.RDF.AJAW.Symbol[]}
* @deprecated Since 2.1. Use {@link Zotero.Translate.IO["rdf"]._RDFBase#getStatementsMatching} * @deprecated Since 2.1. Use {@link Zotero.Translate.IO["rdf"]._RDFBase#getStatementsMatching}
*/ */
"getArcsOut":function(resource) { "getArcsOut":function(resource) {
@ -2495,9 +2495,9 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Gets all subjects whose predicates point to a resource * Gets all subjects whose predicates point to a resource
* @param {String|Zotero.RDF.AJAW.RDFSymbol} resource Subject that predicates should point to * @param {String|Zotero.RDF.AJAW.Symbol} resource Subject that predicates should point to
* @param {String|Zotero.RDF.AJAW.RDFSymbol} property Predicate * @param {String|Zotero.RDF.AJAW.Symbol} property Predicate
* @return {Zotero.RDF.AJAW.RDFSymbol[]} * @return {Zotero.RDF.AJAW.Symbol[]}
* @deprecated Since 2.1. Use {@link Zotero.Translate.IO["rdf"]._RDFBase#getStatementsMatching} * @deprecated Since 2.1. Use {@link Zotero.Translate.IO["rdf"]._RDFBase#getStatementsMatching}
*/ */
"getSources":function(resource, property) { "getSources":function(resource, property) {
@ -2513,9 +2513,9 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Gets all objects of a given subject with a given predicate * Gets all objects of a given subject with a given predicate
* @param {String|Zotero.RDF.AJAW.RDFSymbol} resource Subject * @param {String|Zotero.RDF.AJAW.Symbol} resource Subject
* @param {String|Zotero.RDF.AJAW.RDFSymbol} property Predicate * @param {String|Zotero.RDF.AJAW.Symbol} property Predicate
* @return {Zotero.RDF.AJAW.RDFSymbol[]} * @return {Zotero.RDF.AJAW.Symbol[]}
* @deprecated Since 2.1. Use {@link Zotero.Translate.IO["rdf"]._RDFBase#getStatementsMatching} * @deprecated Since 2.1. Use {@link Zotero.Translate.IO["rdf"]._RDFBase#getStatementsMatching}
*/ */
"getTargets":function(resource, property) { "getTargets":function(resource, property) {
@ -2532,9 +2532,9 @@ Zotero.Translate.IO._RDFSandbox.prototype = {
/** /**
* Gets statements matching a certain pattern * Gets statements matching a certain pattern
* *
* @param {String|Zotero.RDF.AJAW.RDFSymbol} subj Subject * @param {String|Zotero.RDF.AJAW.Symbol} subj Subject
* @param {String|Zotero.RDF.AJAW.RDFSymbol} predicate Predicate * @param {String|Zotero.RDF.AJAW.Symbol} predicate Predicate
* @param {String|Zotero.RDF.AJAW.RDFSymbol} obj Object * @param {String|Zotero.RDF.AJAW.Symbol} obj Object
* @param {Boolean} objLiteral Whether the object is a literal (as * @param {Boolean} objLiteral Whether the object is a literal (as
* opposed to a URI) * opposed to a URI)
* @param {Boolean} justOne Whether to stop when a single result is * @param {Boolean} justOne Whether to stop when a single result is

4
chrome/content/zotero/xpcom/translation/translate_firefox.js
View File

@ -419,7 +419,7 @@ Zotero.Translate.IO.Read.prototype = {
var baseURI = fileHandler.getURLSpecFromFile(this.file); var baseURI = fileHandler.getURLSpecFromFile(this.file);
Zotero.debug("Translate: Initializing RDF data store"); Zotero.debug("Translate: Initializing RDF data store");
this._dataStore = new Zotero.RDF.AJAW.RDFIndexedFormula(); this._dataStore = new Zotero.RDF.AJAW.IndexedFormula();
var parser = new Zotero.RDF.AJAW.RDFParser(this._dataStore); var parser = new Zotero.RDF.AJAW.RDFParser(this._dataStore);
try { try {
var nodes = Zotero.Translate.IO.parseDOMXML(this._rawStream, this._charset, this.file.fileSize); var nodes = Zotero.Translate.IO.parseDOMXML(this._rawStream, this._charset, this.file.fileSize);
@ -521,7 +521,7 @@ Zotero.Translate.IO.Write.prototype = {
"_initRDF":function() { "_initRDF":function() {
Zotero.debug("Translate: Initializing RDF data store"); Zotero.debug("Translate: Initializing RDF data store");
this._dataStore = new Zotero.RDF.AJAW.RDFIndexedFormula(); this._dataStore = new Zotero.RDF.AJAW.IndexedFormula();
this.RDF = new Zotero.Translate.IO._RDFSandbox(this._dataStore); this.RDF = new Zotero.Translate.IO._RDFSandbox(this._dataStore);
}, },

4
components/zotero-service.js
View File

@ -234,14 +234,14 @@ function makeZoteroContext(isConnector) {
// Load RDF files into Zotero.RDF.AJAW namespace (easier than modifying all of the references) // Load RDF files into Zotero.RDF.AJAW namespace (easier than modifying all of the references)
const rdfXpcomFiles = [ const rdfXpcomFiles = [
'rdf/init',
'rdf/uri', 'rdf/uri',
'rdf/term', 'rdf/term',
'rdf/identity', 'rdf/identity',
'rdf/match', 'rdf/match',
'rdf/n3parser', 'rdf/n3parser',
'rdf/rdfparser', 'rdf/rdfparser',
'rdf/serialize', 'rdf/serialize'
'rdf'
]; ];
zContext.Zotero.RDF = {AJAW:{Zotero:zContext.Zotero}}; zContext.Zotero.RDF = {AJAW:{Zotero:zContext.Zotero}};
for (var i=0; i<rdfXpcomFiles.length; i++) { for (var i=0; i<rdfXpcomFiles.length; i++) {