Emit error on unsupported versions

Author: rubensworks

README.md

@@ -61,6 +61,9 @@ fs.createReadStream('myfile.rdf')
   .on('end', () => console.log('All triples were parsed!'));
 ```
 
+The error thrown for unsupported versions can be skipped
+by setting `parseUnsupportedVersions` to `true` when constructing the parser.
+
 ### Manually write strings to the parser
 
 ```javascript
@@ -110,6 +113,8 @@ Optionally, the following parameters can be set in the `RdfXmlParser` constructo
 * `allowDuplicateRdfIds`: By default [multiple occurrences of the same `rdf:ID` value are not allowed](https://www.w3.org/TR/rdf-syntax-grammar/#section-Syntax-ID-xml-base). By setting this option to `true`, this uniqueness check can be disabled. _(Default: `false`)_
 * `validateUri`: By default, the parser validates each URI. _(Default: `true`)_
 * `iriValidationStrategy`: Allows to customize the used IRI validation strategy using the `IriValidationStrategy` enumeration. IRI validation is handled by [validate-iri.js](https://github.com/comunica/validate-iri.js/).  _(Default: `IriValidationStrategy.Pragmatic`)_
+* `parseUnsupportedVersions`: If no error should be emitted on unsupported versions. _(Default: `false`)_
+* `version`: The version that was supplied as a media type parameter. _(Default: `undefined`)_
 
 ```javascript
 new RdfXmlParser({
@@ -120,6 +125,7 @@ new RdfXmlParser({
   trackPosition: true,
   allowDuplicateRdfIds: true,
   validateUri: true,
+  parseUnsupportedVersions: false,
 });
 ```
 

lib/RdfXmlParser.ts

@@ -39,6 +39,11 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
   ];
   // tslint:disable-next-line:max-line-length
   public static readonly NCNAME_MATCHER = /^([A-Za-z\xC0-\xD6\xD8-\xF6\u{F8}-\u{2FF}\u{370}-\u{37D}\u{37F}-\u{1FFF}\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}_])([A-Za-z\xC0-\xD6\xD8-\xF6\u{F8}-\u{2FF}\u{370}-\u{37D}\u{37F}-\u{1FFF}\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}_\-.0-9#xB7\u{0300}-\u{036F}\u{203F}-\u{2040}])*$/u;
+  public static SUPPORTED_VERSIONS: string[] = [
+    '1.2',
+    '1.2-basic',
+    '1.1',
+  ];
 
   public readonly trackPosition?: boolean;
 
@@ -50,6 +55,8 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
   private readonly saxParser: SaxesParser;
   private readonly validateUri: boolean;
   private readonly iriValidationStrategy: IriValidationStrategy;
+  private readonly parseUnsupportedVersions: boolean;
+  private version: string | undefined;
 
   private readonly activeTagStack: IActiveTag[] = [];
   private readonly nodeIds: {[id: string]: boolean} = {};
@@ -76,6 +83,8 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
     if (!this.iriValidationStrategy) {
       this.iriValidationStrategy = this.validateUri ? IriValidationStrategy.Pragmatic : IriValidationStrategy.None;
     }
+    this.parseUnsupportedVersions = !!args?.parseUnsupportedVersions;
+    this.version = args?.version;
 
     this.saxParser = new SaxesParser({ xmlns: true, position: this.trackPosition });
 
@@ -97,6 +106,14 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
   }
 
   public _transform(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null, data?: any) => void) {
+    if (this.version) {
+      const version = this.version;
+      this.version = undefined;
+      if (!this.isValidVersion(version)) {
+        return callback(this.newParseError(`Detected unsupported version as media type parameter: ${version}`));
+      }
+    }
+
     try {
       this.saxParser.write(chunk);
     } catch (e) {
@@ -165,6 +182,14 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
     return this.dataFactory.literal(value, activeTag.datatype ? activeTag.datatype : activeTag.language ? { language: activeTag.language, direction: activeTag.rdfVersion ? activeTag.direction : undefined } : undefined)
   }
 
+  /**
+   * If the given version is valid for this parser to handle.
+   * @param version A version string.
+   */
+  public isValidVersion(version: string): boolean {
+    return this.parseUnsupportedVersions || RdfXmlParser.SUPPORTED_VERSIONS.includes(version);
+  }
+
   protected attachSaxListeners() {
     this.saxParser.on('error', (error) => this.emit('error', error));
     this.saxParser.on('opentag', this.onTag.bind(this));
@@ -761,6 +786,9 @@ while ${attribute.value} and ${activeSubjectValue} where found.`);
   private setVersion(activeTag: IActiveTag, version: string) {
     activeTag.rdfVersion = version;
     this.emit('version', version);
+    if (!this.isValidVersion(version)) {
+      throw this.newParseError(`Detected unsupported version: ${version}`);
+    }
   }
 }
 
@@ -796,6 +824,14 @@ export interface IRdfXmlParserArgs {
    * By default, the "pragmatic" strategy is used.
    */
   iriValidationStrategy?: IriValidationStrategy;
+  /**
+   * If no error should be emitted on unsupported versions.
+   */
+  parseUnsupportedVersions?: boolean;
+  /**
+   * The version that was supplied as a media type parameter.
+   */
+  version?: string;
 }
 
 export interface IActiveTag {

test/RdfXmlParser-test.ts

@@ -2625,6 +2625,64 @@ abc`)).rejects.toBeTruthy();
         return expect(cb).toHaveBeenCalledWith('1.2');
       });
 
+      it('throws on an unsupported rdf:version', async () => {
+        await expect(parse(parser, `<?xml version="1.0"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+            xmlns:dc="http://purl.org/dc/elements/1.1/"
+            xmlns:ex="http://example.org/stuff/1.0/"
+            rdf:version="1.2-unknown">
+  <rdf:Description>
+    <ex:editor>
+      <rdf:Description></rdf:Description>
+    </ex:editor>
+  </rdf:Description>
+</rdf:RDF>`)).rejects.toThrow(`Detected unsupported version: 1.2-unknown`);
+      });
+
+      it('handles an unsupported rdf:version when parseUnsupportedVersions is true', async () => {
+        parser = new RdfXmlParser({ parseUnsupportedVersions: true });
+        await expect(parse(parser, `<?xml version="1.0"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+            xmlns:dc="http://purl.org/dc/elements/1.1/"
+            xmlns:ex="http://example.org/stuff/1.0/"
+            rdf:version="1.2-unknown">
+  <rdf:Description>
+    <ex:editor>
+      <rdf:Description></rdf:Description>
+    </ex:editor>
+  </rdf:Description>
+</rdf:RDF>`)).resolves.toHaveLength(1);
+      });
+
+      it('throws on an unsupported version media type parameter', async () => {
+        parser = new RdfXmlParser({ version: '1.2-unknown' });
+        await expect(parse(parser, `<?xml version="1.0"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+            xmlns:dc="http://purl.org/dc/elements/1.1/"
+            xmlns:ex="http://example.org/stuff/1.0/">
+  <rdf:Description>
+    <ex:editor>
+      <rdf:Description></rdf:Description>
+    </ex:editor>
+  </rdf:Description>
+</rdf:RDF>`)).rejects.toThrow(`Detected unsupported version as media type parameter: 1.2-unknown`);
+      });
+
+      it('handles an unsupported media type parameter when parseUnsupportedVersions is true', async () => {
+        parser = new RdfXmlParser({ parseUnsupportedVersions: true, version: '1.2-unknown' });
+        await expect(parse(parser, `<?xml version="1.0"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+            xmlns:dc="http://purl.org/dc/elements/1.1/"
+            xmlns:ex="http://example.org/stuff/1.0/"
+            rdf:version="1.2-unknown">
+  <rdf:Description>
+    <ex:editor>
+      <rdf:Description></rdf:Description>
+    </ex:editor>
+  </rdf:Description>
+</rdf:RDF>`)).resolves.toHaveLength(1);
+      });
+
       // 2.19
       it('on property elements with rdf:parseType="Triple"', async () => {
         const array = await parse(parser, `<?xml version="1.0"?>