forked from linkeddata/rdflib.js
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathparse.js
More file actions
109 lines (109 loc) · 4.27 KB
/
parse.js
File metadata and controls
109 lines (109 loc) · 4.27 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
import DataFactory from './factories/extended-term-factory';
import jsonldParser from './jsonldparser';
import N3Parser from './n3parser';
import { parseNQuads } from './nquads-parser';
import { parseRDFaDOM } from './rdfaparser';
import RDFParser from './rdfxmlparser';
import sparqlUpdateParser from './patch-parser';
import * as Util from './utils-js';
import { TurtleContentType, N3ContentType, RDFXMLContentType, XHTMLContentType, HTMLContentType, SPARQLUpdateContentType, SPARQLUpdateSingleMatchContentType, JSONLDContentType, NQuadsContentType, NQuadsAltContentType } from './types';
/**
* Parse a string and put the result into the graph kb.
* Normal method is sync.
* Unfortunately jsdonld is currently written to need to be called async.
* If you are parsing JSON-LD and want to know when and whether it succeeded, you need to use the callback param.
* @param str - The input string to parse
* @param kb - The store to use
* @param base - The base URI to use
* @param contentType - The MIME content type string for the input - defaults to text/turtle
* @param [callback] - The callback to call when the data has been loaded
*/
export default function parse(str, kb, base, contentType = 'text/turtle', callback) {
contentType = contentType || TurtleContentType;
contentType = contentType.split(';')[0];
try {
if (contentType === N3ContentType || contentType === TurtleContentType) {
var p = N3Parser(kb, kb, base, base, null, null, '', null);
p.loadBuf(str);
executeCallback();
} else if (contentType === RDFXMLContentType) {
var parser = new RDFParser(kb);
parser.parse(Util.parseXML(str), base, kb.sym(base));
executeCallback();
} else if (contentType === XHTMLContentType) {
parseRDFaDOM(Util.parseXML(str, {
contentType: XHTMLContentType
}), kb, base);
executeCallback();
} else if (contentType === HTMLContentType) {
parseRDFaDOM(Util.parseXML(str, {
contentType: HTMLContentType
}), kb, base);
executeCallback();
} else if (contentType === SPARQLUpdateContentType || contentType === SPARQLUpdateSingleMatchContentType) {
// @@ we handle a subset
sparqlUpdateParser(str, kb, base);
executeCallback();
} else if (contentType === JSONLDContentType) {
// since we do not await the promise here, rejections will not be covered by the surrounding try catch
// we do not use await, because parse() should stay sync
// so, to not lose the async error, we need to catch the rejection and call the error callback here too
jsonldParser(str, kb, base).then(executeCallback).catch(executeErrorCallback);
} else if (contentType === NQuadsContentType || contentType === NQuadsAltContentType) {
parseNQuads(str, DataFactory, (err, quad) => {
if (err) {
executeErrorCallback(err);
} else if (quad) {
kb.add(quad.subject, quad.predicate, quad.object, quad.graph);
} else {
// null quad signals end of parsing
executeCallback();
}
});
} else if (contentType === undefined) {
throw new Error("contentType is undefined");
} else {
throw new Error("Don't know how to parse " + contentType + ' yet');
}
} catch (e) {
// @ts-ignore
executeErrorCallback(e);
}
parse.handled = {
'text/n3': true,
'text/turtle': true,
'application/rdf+xml': true,
'application/xhtml+xml': true,
'text/html': true,
'application/sparql-update': true,
'application/sparql-update-single-match': true,
'application/ld+json': true,
'application/nquads': true,
'application/n-quads': true
};
function executeCallback() {
if (callback) {
callback(null, kb);
} else {
return;
}
}
function executeErrorCallback(e) {
if (
// TODO: Always true, what is the right behavior
contentType !== JSONLDContentType ||
// @ts-ignore always true?
contentType !== NQuadsContentType ||
// @ts-ignore always true?
contentType !== NQuadsAltContentType) {
if (callback) {
callback(e, kb);
} else {
let e2 = new Error('' + e + ' while trying to parse <' + base + '> as ' + contentType);
//@ts-ignore .cause is not a default error property
e2.cause = e;
throw e2;
}
}
}
}