N3DataFactory.js

import namespaces from './IRIs';

const { rdf, xsd } = namespaces;

let DEFAULTGRAPH;
let _blankNodeCounter = 0;

const escapedLiteral = /^"(.*".*)(?="[^"]*$)/;

const DataFactory = {
  namedNode,
  blankNode,
  variable,
  literal,
  defaultGraph,
  quad,
  triple: quad,
};
export default DataFactory;

export class Term {
  constructor(id) {
    this.id = id;
  }

  get value() {
    return this.id;
  }

  equals(other) {

    if (other instanceof Term)
      return this.id === other.id;

    return !!other && this.termType === other.termType &&
                      this.value    === other.value;
  }

  hashCode() {
    return 0;
  }

  toJSON() {
    return {
      termType: this.termType,
      value:    this.value,
    };
  }
}

export class NamedNode extends Term {

  get termType() {
    return 'NamedNode';
  }
}

export class Literal extends Term {

  get termType() {
    return 'Literal';
  }

  get value() {
    return this.id.substring(1, this.id.lastIndexOf('"'));
  }

  get language() {

    const id = this.id;
    let atPos = id.lastIndexOf('"') + 1;

    return atPos < id.length && id[atPos++] === '@' ? id.substr(atPos).toLowerCase() : '';
  }

  get datatype() {
    return new NamedNode(this.datatypeString);
  }

  get datatypeString() {

    const id = this.id, dtPos = id.lastIndexOf('"') + 1;
    const char = dtPos < id.length ? id[dtPos] : '';

    return char === '^' ? id.substr(dtPos + 2) :

           (char !== '@' ? xsd.string : rdf.langString);
  }

  equals(other) {

    if (other instanceof Literal)
      return this.id === other.id;

    return !!other && !!other.datatype &&
                      this.termType === other.termType &&
                      this.value    === other.value    &&
                      this.language === other.language &&
                      this.datatype.value === other.datatype.value;
  }

  toJSON() {
    return {
      termType: this.termType,
      value:    this.value,
      language: this.language,
      datatype: { termType: 'NamedNode', value: this.datatypeString },
    };
  }
}

export class BlankNode extends Term {
  constructor(name) {
    super(`_:${name}`);
  }

  get termType() {
    return 'BlankNode';
  }

  get value() {
    return this.id.substr(2);
  }
}

export class Variable extends Term {
  constructor(name) {
    super(`?${name}`);
  }

  get termType() {
    return 'Variable';
  }

  get value() {
    return this.id.substr(1);
  }
}

export class DefaultGraph extends Term {
  constructor() {
    super('');
    return DEFAULTGRAPH || this;
  }

  get termType() {
    return 'DefaultGraph';
  }

  equals(other) {

    return (this === other) || (!!other && (this.termType === other.termType));
  }
}

DEFAULTGRAPH = new DefaultGraph();

export function termFromId(id, factory, nested) {
  factory = factory || DataFactory;

  if (!id)
    return factory.defaultGraph();

  switch (id[0]) {
  case '?':
    return factory.variable(id.substr(1));
  case '_':
    return factory.blankNode(id.substr(2));
  case '"':

    if (factory === DataFactory)
      return new Literal(id);

    if (id[id.length - 1] === '"')
      return factory.literal(id.substr(1, id.length - 2));

    const endPos = id.lastIndexOf('"', id.length - 1);
    return factory.literal(id.substr(1, endPos - 1),
            id[endPos + 1] === '@' ? id.substr(endPos + 2)
                                   : factory.namedNode(id.substr(endPos + 3)));
  case '[':
    id = JSON.parse(id);
    break;
  default:
    if (!nested || !Array.isArray(id)) {
      return factory.namedNode(id);
    }
  }
  return factory.quad(
    termFromId(id[0], factory, true),
    termFromId(id[1], factory, true),
    termFromId(id[2], factory, true),
    id[3] && termFromId(id[3], factory, true)
  );
}

export function termToId(term, nested) {
  if (typeof term === 'string')
    return term;
  if (term instanceof Term && term.termType !== 'Quad')
    return term.id;
  if (!term)
    return DEFAULTGRAPH.id;

  switch (term.termType) {
  case 'NamedNode':    return term.value;
  case 'BlankNode':    return `_:${term.value}`;
  case 'Variable':     return `?${term.value}`;
  case 'DefaultGraph': return '';
  case 'Literal':      return `"${term.value}"${
    term.language ? `@${term.language}` :
      (term.datatype && term.datatype.value !== xsd.string ? `^^${term.datatype.value}` : '')}`;
  case 'Quad':
    const res = [
      termToId(term.subject, true),
      termToId(term.predicate, true),
      termToId(term.object, true),
    ];
    if (term.graph && term.graph.termType !== 'DefaultGraph') {
      res.push(termToId(term.graph, true));
    }
    return nested ? res : JSON.stringify(res);
  default: throw new Error(`Unexpected termType: ${term.termType}`);
  }
}

export class Quad extends Term {
  constructor(subject, predicate, object, graph) {
    super('');
    this._subject   = subject;
    this._predicate = predicate;
    this._object    = object;
    this._graph     = graph || DEFAULTGRAPH;
  }

  get termType() {
    return 'Quad';
  }

  get subject() {
    return this._subject;
  }

  get predicate() {
    return this._predicate;
  }

  get object() {
    return this._object;
  }

  get graph() {
    return this._graph;
  }

  toJSON() {
    return {
      termType:  this.termType,
      subject:   this._subject.toJSON(),
      predicate: this._predicate.toJSON(),
      object:    this._object.toJSON(),
      graph:     this._graph.toJSON(),
    };
  }

  equals(other) {
    return !!other && this._subject.equals(other.subject)     &&
                      this._predicate.equals(other.predicate) &&
                      this._object.equals(other.object)       &&
                      this._graph.equals(other.graph);
  }
}
export { Quad as Triple };

export function escapeQuotes(id) {
  return id.replace(escapedLiteral, (_, quoted) => `"${quoted.replace(/"/g, '""')}`);
}

export function unescapeQuotes(id) {
  return id.replace(escapedLiteral, (_, quoted) => `"${quoted.replace(/""/g, '"')}`);
}

function namedNode(iri) {
  return new NamedNode(iri);
}

function blankNode(name) {
  return new BlankNode(name || `n3-${_blankNodeCounter++}`);
}

function literal(value, languageOrDataType) {

  if (typeof languageOrDataType === 'string')
    return new Literal(`"${value}"@${languageOrDataType.toLowerCase()}`);

  let datatype = languageOrDataType ? languageOrDataType.value : '';
  if (datatype === '') {

    if (typeof value === 'boolean')
      datatype = xsd.boolean;

    else if (typeof value === 'number') {
      if (Number.isFinite(value))
        datatype = Number.isInteger(value) ? xsd.integer : xsd.double;
      else {
        datatype = xsd.double;
        if (!Number.isNaN(value))
          value = value > 0 ? 'INF' : '-INF';
      }
    }
  }

  return (datatype === '' || datatype === xsd.string) ?
    new Literal(`"${value}"`) :
    new Literal(`"${value}"^^${datatype}`);
}

function variable(name) {
  return new Variable(name);
}

function defaultGraph() {
  return DEFAULTGRAPH;
}

function quad(subject, predicate, object, graph) {
  return new Quad(subject, predicate, object, graph);
}