@skaterqiang/protege-js 0.1.0

package/src/io/RDFXMLParser.js

@@ -0,0 +1,319 @@
+'use strict';
+
+const { OWLOntology, OWLOntologyID } = require('../model/OWLOntology');
+const {
+  OWLClass, OWLObjectProperty, OWLDataProperty, OWLNamedIndividual,
+  OWLAnnotationProperty
+} = require('../model/OWLEntity');
+const {
+  OWLDeclarationAxiom, OWLSubClassOfAxiom, OWLEquivalentClassesAxiom,
+  OWLSubObjectPropertyOfAxiom, OWLSubDataPropertyOfAxiom,
+  OWLObjectPropertyDomainAxiom, OWLObjectPropertyRangeAxiom,
+  OWLDataPropertyDomainAxiom, OWLClassAssertionAxiom,
+  OWLObjectPropertyAssertionAxiom, OWLDataPropertyAssertionAxiom,
+  OWLAnnotationAssertionAxiom,
+  OWLDisjointClassesAxiom, OWLInverseObjectPropertiesAxiom,
+  OWLSameIndividualAxiom, OWLDifferentIndividualsAxiom,
+  OWLFunctionalObjectPropertyAxiom, OWLInverseFunctionalObjectPropertyAxiom,
+  OWLTransitiveObjectPropertyAxiom, OWLSymmetricObjectPropertyAxiom,
+  OWLAsymmetricObjectPropertyAxiom, OWLReflexiveObjectPropertyAxiom,
+  OWLIrreflexiveObjectPropertyAxiom, OWLFunctionalDataPropertyAxiom
+} = require('../model/OWLAxiom');
+const { OWLLiteral } = require('../model/OWLLiteral');
+
+// ---------------------------------------------------------------------------
+// io/RDFXMLParser — mirrors the RDF/XML document handler role of OWLAPI's
+// parsers as wrapped by org.protege.editor.owl.model.io.OntologyLoader.
+//
+// A lightweight, dependency-free RDF/XML reader: extracts typed nodes,
+// rdf:about / rdf:ID identity, owl:subClassOf / subPropertyOf / domain /
+// range / type triples, and rdfs:label / annotation literals.
+// ---------------------------------------------------------------------------
+
+const NS = Object.freeze({
+  RDF: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  RDFS: 'http://www.w3.org/2000/01/rdf-schema#',
+  OWL: 'http://www.w3.org/2002/07/owl#',
+  XSD: 'http://www.w3.org/2001/XMLSchema#'
+});
+
+function expandIRI(token, base, prefixes) {
+  if (!token) return null;
+  if (token.startsWith('http://') || token.startsWith('https://') || token.startsWith('urn:')) {
+    return token;
+  }
+  const idx = token.indexOf(':');
+  if (idx > 0) {
+    const ns = prefixes[token.slice(0, idx)];
+    if (ns) return ns + token.slice(idx + 1);
+  }
+  return base ? base + token : token;
+}
+
+/** Parse RDF/XML text into an OWLOntology. */
+function parseRDFXML(xmlText, ontologyIRI = null) {
+  const prefixes = { rdf: NS.RDF, rdfs: NS.RDFS, owl: NS.OWL, xsd: NS.XSD };
+
+  // Collect namespace declarations.
+  const nsRe = /xmlns:([A-Za-z0-9_-]+)\s*=\s*"([^"]+)"/g;
+  let m;
+  while ((m = nsRe.exec(xmlText)) !== null) {
+    prefixes[m[1]] = m[2];
+  }
+  const baseMatch = /xml:base\s*=\s*"([^"]+)"/.exec(xmlText);
+  const base = baseMatch ? baseMatch[1] : null;
+
+  const ontIRI = ontologyIRI
+    || (/<owl:Ontology[^>]*rdf:about="([^"]+)"/.exec(xmlText) || [])[1]
+    || null;
+  const ont = new OWLOntology(new OWLOntologyID(ontIRI));
+  ont.format = 'RDF/XML';
+
+  // --- element scanning (flat, order-independent) --------------------------
+  // We use a simple element splitter: match top-level typed blocks, plus the
+  // generic rdf:Description style where the entity type comes from rdf:type.
+  const classBlocks = matchBlocks(xmlText, 'owl:Class');
+  const objPropBlocks = matchBlocks(xmlText, 'owl:ObjectProperty');
+  const dataPropBlocks = matchBlocks(xmlText, 'owl:DatatypeProperty');
+  const individualBlocks = matchBlocks(xmlText, 'owl:NamedIndividual');
+
+  const descBlocks = matchDescriptionBlocks(xmlText);
+  for (const b of descBlocks) {
+    // Punning: a single Description may carry MULTIPLE entity types
+    // (e.g. both owl:Class and owl:ObjectProperty). Register the block in
+    // EVERY matching category instead of breaking after the first.
+    for (const t of b.types) {
+      if (t === NS.OWL + 'Class' || t === NS.RDFS + 'Class') { classBlocks.push(b); continue; }
+      if (t === NS.OWL + 'ObjectProperty') { objPropBlocks.push(b); continue; }
+      if (t === NS.OWL + 'DatatypeProperty') { dataPropBlocks.push(b); continue; }
+      if (t === NS.OWL + 'NamedIndividual') { individualBlocks.push(b); continue; }
+    }
+  }
+
+  for (const b of classBlocks) {
+    const iri = entityIRIFromTag(b.tag, base, prefixes);
+    if (!iri) continue;
+    const cls = new OWLClass(iri);
+    ont.addAxiom(new OWLDeclarationAxiom(cls));
+    parseClassBody(cls, b.body, ont, base, prefixes);
+  }
+
+  for (const b of objPropBlocks) {
+    const iri = entityIRIFromTag(b.tag, base, prefixes);
+    if (!iri) continue;
+    const p = new OWLObjectProperty(iri);
+    ont.addAxiom(new OWLDeclarationAxiom(p));
+    parsePropertyBody(p, b.body, ont, base, prefixes, true);
+    applyCharacteristics(p, b.body, ont, base, prefixes, true);
+  }
+
+  for (const b of dataPropBlocks) {
+    const iri = entityIRIFromTag(b.tag, base, prefixes);
+    if (!iri) continue;
+    const p = new OWLDataProperty(iri);
+    ont.addAxiom(new OWLDeclarationAxiom(p));
+    parsePropertyBody(p, b.body, ont, base, prefixes, false);
+    applyCharacteristics(p, b.body, ont, base, prefixes, false);
+  }
+
+  for (const b of individualBlocks) {
+    const iri = entityIRIFromTag(b.tag, base, prefixes);
+    if (!iri) continue;
+    const ind = new OWLNamedIndividual(iri);
+    ont.addAxiom(new OWLDeclarationAxiom(ind));
+    parseIndividualBody(ind, b.body, ont, base, prefixes);
+  }
+
+  return ont;
+}
+
+// --- helpers ---------------------------------------------------------------
+
+function matchBlocks(xml, tagName) {
+  const blocks = [];
+  // Self-closing: <owl:Class rdf:about="..."/>
+  const selfRe = new RegExp(`<${tagName}([^>]*)/>`, 'g');
+  let m;
+  while ((m = selfRe.exec(xml)) !== null) {
+    blocks.push({ tag: m[1], body: '' });
+  }
+  // Paired: <owl:Class rdf:about="..."> ... </owl:Class>
+  const pairRe = new RegExp(`<${tagName}([^>]*)>([\\s\\S]*?)</${tagName}>`, 'g');
+  while ((m = pairRe.exec(xml)) !== null) {
+    blocks.push({ tag: m[1], body: m[2] });
+  }
+  return blocks;
+}
+
+/**
+ * Also support the generic `rdf:Description` style where the entity type is
+ * given by an inner `<rdf:type rdf:resource="...#Class"/>` triple. Returns
+ * blocks in the same {tag, body} shape but with a derived `type` field.
+ */
+function matchDescriptionBlocks(xml) {
+  const blocks = [];
+  const pairRe = /<rdf:Description([^>]*)>([\s\S]*?)<\/rdf:Description>/g;
+  let m;
+  while ((m = pairRe.exec(xml)) !== null) {
+    const attrs = m[1];
+    const body = m[2];
+    // Collect ALL rdf:type values (an individual may have several types).
+    const types = [];
+    const tRe = /<rdf:type[^>]*rdf:resource="([^"]+)"/g;
+    let tm;
+    while ((tm = tRe.exec(body)) !== null) types.push(tm[1]);
+    if (!types.length) continue;
+    blocks.push({ tag: attrs, body, types });
+  }
+  return blocks;
+}
+
+function entityIRIFromTag(tagAttrs, base, prefixes) {
+  const about = /rdf:about="([^"]+)"/.exec(tagAttrs);
+  if (about) return expandIRI(about[1], base, prefixes);
+  const id = /rdf:ID="([^"]+)"/.exec(tagAttrs);
+  if (id) return base ? base + '#' + id[1] : '#' + id[1];
+  return null;
+}
+
+function resourcesOf(body, tagName) {
+  const out = [];
+  const re = new RegExp(`<${tagName}[^>]*rdf:resource="([^"]+)"`, 'g');
+  let m;
+  while ((m = re.exec(body)) !== null) out.push(m[1]);
+  return out;
+}
+
+function literalsOf(body, tagName) {
+  const out = [];
+  const re = new RegExp(`<${tagName}[^>]*>([^<]*)</${tagName}>`, 'g');
+  let m;
+  while ((m = re.exec(body)) !== null) out.push(m[1].trim());
+  return out;
+}
+
+function parseClassBody(cls, body, ont, base, prefixes) {
+  for (const r of resourcesOf(body, 'rdfs:subClassOf')) {
+    const supIRI = expandIRI(r, base, prefixes);
+    ont.addAxiom(new OWLDeclarationAxiom(new OWLClass(supIRI)));
+    ont.addAxiom(new OWLSubClassOfAxiom(cls, new OWLClass(supIRI)));
+  }
+  for (const r of resourcesOf(body, 'owl:equivalentClass')) {
+    const eqIRI = expandIRI(r, base, prefixes);
+    ont.addAxiom(new OWLDeclarationAxiom(new OWLClass(eqIRI)));
+    ont.addAxiom(new OWLEquivalentClassesAxiom([cls, new OWLClass(eqIRI)]));
+  }
+  for (const r of resourcesOf(body, 'owl:disjointWith')) {
+    const dIRI = expandIRI(r, base, prefixes);
+    ont.addAxiom(new OWLDeclarationAxiom(new OWLClass(dIRI)));
+    ont.addAxiom(new OWLDisjointClassesAxiom([cls, new OWLClass(dIRI)]));
+  }
+  addLabels(cls.getIRI().toString(), body, ont);
+}
+
+function parsePropertyBody(prop, body, ont, base, prefixes, isObject) {
+  const subTag = 'rdfs:subPropertyOf';
+  const subType = isObject ? OWLSubObjectPropertyOfAxiom : OWLSubDataPropertyOfAxiom;
+  const mk = isObject ? (i) => new OWLObjectProperty(i) : (i) => new OWLDataProperty(i);
+  for (const r of resourcesOf(body, subTag)) {
+    const supIRI = expandIRI(r, base, prefixes);
+    ont.addAxiom(new OWLDeclarationAxiom(mk(supIRI)));
+    ont.addAxiom(new subType(prop, mk(supIRI)));
+  }
+  for (const r of resourcesOf(body, 'rdfs:domain')) {
+    const dIRI = expandIRI(r, base, prefixes);
+    const dCls = new OWLClass(dIRI);
+    ont.addAxiom(new OWLDeclarationAxiom(dCls));
+    ont.addAxiom(isObject
+      ? new OWLObjectPropertyDomainAxiom(prop, dCls)
+      : new OWLDataPropertyDomainAxiom(prop, dCls));
+  }
+  for (const r of resourcesOf(body, 'rdfs:range')) {
+    const rIRI = expandIRI(r, base, prefixes);
+    const rCls = new OWLClass(rIRI);
+    ont.addAxiom(new OWLDeclarationAxiom(rCls));
+    if (isObject) ont.addAxiom(new OWLObjectPropertyRangeAxiom(prop, rCls));
+  }
+  if (isObject) {
+    for (const r of resourcesOf(body, 'owl:inverseOf')) {
+      const invIRI = expandIRI(r, base, prefixes);
+      const invProp = new OWLObjectProperty(invIRI);
+      ont.addAxiom(new OWLDeclarationAxiom(invProp));
+      ont.addAxiom(new OWLInverseObjectPropertiesAxiom(prop, invProp));
+    }
+  }
+  addLabels(prop.getIRI().toString(), body, ont);
+}
+
+// Property characteristics expressed as rdf:type of the property node.
+const CHARACTERISTIC_TYPES = {
+  [NS.OWL + 'FunctionalProperty']: (p, ont, isObject) => {
+    ont.addAxiom(isObject
+      ? new OWLFunctionalObjectPropertyAxiom(p)
+      : new OWLFunctionalDataPropertyAxiom(p));
+  },
+  [NS.OWL + 'InverseFunctionalProperty']: (p, ont) => {
+    ont.addAxiom(new OWLInverseFunctionalObjectPropertyAxiom(p));
+  },
+  [NS.OWL + 'TransitiveProperty']: (p, ont) => {
+    ont.addAxiom(new OWLTransitiveObjectPropertyAxiom(p));
+  },
+  [NS.OWL + 'SymmetricProperty']: (p, ont) => {
+    ont.addAxiom(new OWLSymmetricObjectPropertyAxiom(p));
+  },
+  [NS.OWL + 'AsymmetricProperty']: (p, ont) => {
+    ont.addAxiom(new OWLAsymmetricObjectPropertyAxiom(p));
+  },
+  [NS.OWL + 'ReflexiveProperty']: (p, ont) => {
+    ont.addAxiom(new OWLReflexiveObjectPropertyAxiom(p));
+  },
+  [NS.OWL + 'IrreflexiveProperty']: (p, ont) => {
+    ont.addAxiom(new OWLIrreflexiveObjectPropertyAxiom(p));
+  }
+};
+
+function applyCharacteristics(prop, body, ont, base, prefixes, isObject) {
+  for (const r of resourcesOf(body, 'rdf:type')) {
+    const tIRI = expandIRI(r, base, prefixes);
+    const fn = CHARACTERISTIC_TYPES[tIRI];
+    if (fn) fn(prop, ont, isObject);
+  }
+}
+
+function parseIndividualBody(ind, body, ont, base, prefixes) {
+  for (const r of resourcesOf(body, 'rdf:type')) {
+    const tIRI = expandIRI(r, base, prefixes);
+    if (tIRI === NS.OWL + 'NamedIndividual') continue;
+    const tCls = new OWLClass(tIRI);
+    ont.addAxiom(new OWLDeclarationAxiom(tCls));
+    ont.addAxiom(new OWLClassAssertionAxiom(ind, tCls));
+  }
+  for (const r of resourcesOf(body, 'owl:sameAs')) {
+    const oIRI = expandIRI(r, base, prefixes);
+    ont.addAxiom(new OWLSameIndividualAxiom([ind, new OWLNamedIndividual(oIRI)]));
+  }
+  for (const r of resourcesOf(body, 'owl:differentFrom')) {
+    const oIRI = expandIRI(r, base, prefixes);
+    ont.addAxiom(new OWLDifferentIndividualsAxiom([ind, new OWLNamedIndividual(oIRI)]));
+  }
+  addLabels(ind.getIRI().toString(), body, ont);
+}
+
+function addLabels(subjectIRI, body, ont) {
+  for (const text of literalsOf(body, 'rdfs:label')) {
+    ont.addAxiom(new OWLAnnotationAssertionAxiom(
+      subjectIRI,
+      new OWLAnnotationProperty(NS.RDFS + 'label'),
+      new OWLLiteral(text)
+    ));
+  }
+  for (const text of literalsOf(body, 'rdfs:comment')) {
+    ont.addAxiom(new OWLAnnotationAssertionAxiom(
+      subjectIRI,
+      new OWLAnnotationProperty(NS.RDFS + 'comment'),
+      new OWLLiteral(text)
+    ));
+  }
+}
+
+module.exports = { parseRDFXML, NS };

package/src/io/RDFXMLWriter.js

@@ -0,0 +1,196 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// io/RDFXMLWriter — serialize an OWLOntology to RDF/XML.
+// Compact writer covering the common axiom shapes; counterpart to
+// RDFXMLParser. Produces rdf:RDF with owl:Class / owl:ObjectProperty
+// elements and rdf:Description-based assertions.
+// ---------------------------------------------------------------------------
+
+const { ClassExpressionType: T } = require('../model/OWLClassExpression');
+const { AxiomType: A } = require('../model/OWLAxiom');
+
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const RDFS = 'http://www.w3.org/2000/01/rdf-schema#';
+const OWL = 'http://www.w3.org/2002/07/owl#';
+const XSD = 'http://www.w3.org/2001/XMLSchema#';
+
+function esc(s) {
+  return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+function iriOf(x) {
+  return x && x.getIRI ? x.getIRI().toString() : String(x);
+}
+
+function litXML(l) {
+  const v = esc(l.lexicalValue !== undefined ? l.lexicalValue : l.getLiteral());
+  const dt = l.datatype ? iriOf(l.datatype) : null;
+  const lang = l.lang || null;
+  if (lang) return ` xml:lang="${esc(lang)}">${v}`;
+  if (dt && dt !== XSD + 'string') return ` rdf:datatype="${esc(dt)}">${v}`;
+  return `>${v}`;
+}
+
+class RDFXMLWriter {
+  constructor(ont) {
+    this.ont = ont;
+    this.out = [];
+    this.bn = 0;
+  }
+
+  write() {
+    const o = this.ont;
+    const id = o.getOntologyID();
+    const oIRI = id && id.ontologyIRI ? iriOf(id.ontologyIRI) : null;
+
+    this.out.push('<?xml version="1.0"?>');
+    this.out.push(`<rdf:RDF xmlns:rdf="${RDF}"`);
+    this.out.push(`     xmlns:rdfs="${RDFS}"`);
+    this.out.push(`     xmlns:owl="${OWL}"`);
+    this.out.push(`     xmlns:xsd="${XSD}"${oIRI ? `\n     xml:base="${esc(oIRI)}"` : ''}>`);
+
+    if (oIRI) {
+      this.out.push(`  <owl:Ontology rdf:about="${esc(oIRI)}">`);
+      for (const imp of (o.imports || [])) {
+        this.out.push(`    <owl:imports rdf:resource="${esc(iriOf(imp))}"/>`);
+      }
+      this.out.push(`  </owl:Ontology>`);
+    }
+
+    for (const ax of o.getAxioms()) {
+      this._axiom(ax);
+    }
+
+    this.out.push('</rdf:RDF>');
+    return this.out.join('\n') + '\n';
+  }
+
+  _bnode() { return 'b' + (this.bn++); }
+
+  // class expression → nested XML (returns string to embed)
+  _ce(e, indent) {
+    const pad = ' '.repeat(indent);
+    if (!e) return '';
+    if (e.getIRI) return `<rdf:Description rdf:about="${esc(iriOf(e))}"/>`;
+    switch (e.type) {
+      case T.OBJECT_SOME_VALUES_FROM:
+        return `<owl:Restriction><owl:onProperty rdf:resource="${esc(iriOf(e.property))}"/><owl:someValuesFrom rdf:resource="${esc(iriOf(e.filler))}"/></owl:Restriction>`;
+      case T.OBJECT_ALL_VALUES_FROM:
+        return `<owl:Restriction><owl:onProperty rdf:resource="${esc(iriOf(e.property))}"/><owl:allValuesFrom rdf:resource="${esc(iriOf(e.filler))}"/></owl:Restriction>`;
+      case T.OBJECT_HAS_VALUE:
+        return `<owl:Restriction><owl:onProperty rdf:resource="${esc(iriOf(e.property))}"/><owl:hasValue rdf:resource="${esc(iriOf(e.value))}"/></owl:Restriction>`;
+      case T.OBJECT_INTERSECTION_OF: {
+        const items = e.operands.map(x => `<rdf:Description rdf:about="${esc(iriOf(x))}"/>`).join('');
+        return `<owl:Class><owl:intersectionOf rdf:parseType="Collection">${items}</owl:intersectionOf></owl:Class>`;
+      }
+      default:
+        return `<rdf:Description rdf:about="${esc(iriOf(e))}"/>`;
+    }
+  }
+
+  _axiom(ax) {
+    switch (ax.getAxiomType()) {
+      case A.DECLARATION: {
+        const e = ax.entity;
+        const tagMap = {
+          OWLClass: 'owl:Class',
+          OWLObjectProperty: 'owl:ObjectProperty',
+          OWLDataProperty: 'owl:DatatypeProperty',
+          OWLNamedIndividual: 'owl:NamedIndividual',
+          OWLAnnotationProperty: 'owl:AnnotationProperty',
+          OWLDatatype: 'rdfs:Datatype'
+        };
+        const tag = tagMap[e.constructor.name];
+        if (tag) this.out.push(`  <${tag} rdf:about="${esc(iriOf(e))}"/>`);
+        break;
+      }
+      case A.SUBCLASS_OF: {
+        const sub = ax.subClass, sup = ax.superClass;
+        if (sub.getIRI) {
+          if (sup.getIRI) {
+            this.out.push(`  <owl:Class rdf:about="${esc(iriOf(sub))}"><rdfs:subClassOf rdf:resource="${esc(iriOf(sup))}"/></owl:Class>`);
+          } else {
+            this.out.push(`  <owl:Class rdf:about="${esc(iriOf(sub))}"><rdfs:subClassOf>${this._ce(sup, 4)}</rdfs:subClassOf></owl:Class>`);
+          }
+        }
+        break;
+      }
+      case A.EQUIVALENT_CLASSES: {
+        const ces = ax.classExpressions;
+        for (let i = 0; i < ces.length - 1; i++) {
+          if (ces[i].getIRI && ces[i + 1].getIRI) {
+            this.out.push(`  <owl:Class rdf:about="${esc(iriOf(ces[i]))}"><owl:equivalentClass rdf:resource="${esc(iriOf(ces[i + 1]))}"/></owl:Class>`);
+          }
+        }
+        break;
+      }
+      case A.DISJOINT_CLASSES: {
+        const ces = ax.classExpressions;
+        for (let i = 0; i < ces.length; i++) {
+          for (let j = i + 1; j < ces.length; j++) {
+            if (ces[i].getIRI && ces[j].getIRI) {
+              this.out.push(`  <owl:Class rdf:about="${esc(iriOf(ces[i]))}"><owl:disjointWith rdf:resource="${esc(iriOf(ces[j]))}"/></owl:Class>`);
+            }
+          }
+        }
+        break;
+      }
+      case A.OBJECT_PROPERTY_DOMAIN:
+        if (ax.domain.getIRI) this.out.push(`  <owl:ObjectProperty rdf:about="${esc(iriOf(ax.property))}"><rdfs:domain rdf:resource="${esc(iriOf(ax.domain))}"/></owl:ObjectProperty>`);
+        break;
+      case A.OBJECT_PROPERTY_RANGE:
+        if (ax.range.getIRI) this.out.push(`  <owl:ObjectProperty rdf:about="${esc(iriOf(ax.property))}"><rdfs:range rdf:resource="${esc(iriOf(ax.range))}"/></owl:ObjectProperty>`);
+        break;
+      case A.SUB_OBJECT_PROPERTY_OF:
+        this.out.push(`  <owl:ObjectProperty rdf:about="${esc(iriOf(ax.subProperty))}"><rdfs:subPropertyOf rdf:resource="${esc(iriOf(ax.superProperty))}"/></owl:ObjectProperty>`);
+        break;
+      case A.INVERSE_OBJECT_PROPERTIES:
+        this.out.push(`  <owl:ObjectProperty rdf:about="${esc(iriOf(ax.property1))}"><owl:inverseOf rdf:resource="${esc(iriOf(ax.property2))}"/></owl:ObjectProperty>`);
+        break;
+      case A.FUNCTIONAL_OBJECT_PROPERTY:
+        this.out.push(`  <owl:ObjectProperty rdf:about="${esc(iriOf(ax.property))}"><rdf:type rdf:resource="${OWL}FunctionalProperty"/></owl:ObjectProperty>`);
+        break;
+      case A.TRANSITIVE_OBJECT_PROPERTY:
+        this.out.push(`  <owl:ObjectProperty rdf:about="${esc(iriOf(ax.property))}"><rdf:type rdf:resource="${OWL}TransitiveProperty"/></owl:ObjectProperty>`);
+        break;
+      case A.CLASS_ASSERTION:
+        this.out.push(`  <owl:NamedIndividual rdf:about="${esc(iriOf(ax.individual))}"><rdf:type rdf:resource="${esc(iriOf(ax.classExpression))}"/></owl:NamedIndividual>`);
+        break;
+      case A.OBJECT_PROPERTY_ASSERTION: {
+        // Use rdf:Description with property element
+        this.out.push(`  <rdf:Description rdf:about="${esc(iriOf(ax.subject))}"><ns0:${localName(iriOf(ax.property))} xmlns:ns0="${namespaceOf(iriOf(ax.property))}" rdf:resource="${esc(iriOf(ax.object))}"/></rdf:Description>`);
+        break;
+      }
+      case A.SAME_INDIVIDUAL: {
+        const inds = ax.individuals;
+        for (let i = 0; i < inds.length - 1; i++) {
+          this.out.push(`  <rdf:Description rdf:about="${esc(iriOf(inds[i]))}"><owl:sameAs rdf:resource="${esc(iriOf(inds[i + 1]))}"/></rdf:Description>`);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+
+function localName(iri) {
+  const i = Math.max(iri.lastIndexOf('#'), iri.lastIndexOf('/'));
+  return i >= 0 ? iri.slice(i + 1) : iri;
+}
+function namespaceOf(iri) {
+  const i = Math.max(iri.lastIndexOf('#'), iri.lastIndexOf('/'));
+  return i >= 0 ? iri.slice(0, i + 1) : iri;
+}
+
+/**
+ * Serialize an OWLOntology to RDF/XML.
+ * @param {OWLOntology} ont
+ * @returns {string}
+ */
+function writeRDFXML(ont) {
+  return new RDFXMLWriter(ont).write();
+}
+
+module.exports = { writeRDFXML, RDFXMLWriter };

package/src/io/SWRLParser.js

@@ -0,0 +1,150 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// io/SWRLParser — parse Protégé-style SWRL text rules into SWRLRule objects.
+// Syntax:  Antecedent ^ Antecedent ... -> Consequent ^ Consequent ...
+// Atoms:
+//   Class(?x)            → SWRLClassAtom
+//   prop(?x, ?y)         → ObjectPropertyAtom or DataPropertyAtom (resolved)
+//   sameAs(?x, ?y)       → SWRLSameAsAtom
+//   differentFrom(?x,?y) → SWRLDifferentFromAtom
+//   builtin(?x, "lit")   → SWRLBuiltInAtom (swrlb namespace)
+// Variables: ?name.  Individuals/IRIs: prefixed name or <iri> or bare token.
+// ---------------------------------------------------------------------------
+
+const {
+  SWRLRule, SWRLVariable, SWRLClassAtom, SWRLObjectPropertyAtom,
+  SWRLDataPropertyAtom, SWRLSameAsAtom, SWRLDifferentFromAtom,
+  SWRLBuiltInAtom, SWRLB_NS
+} = require('../model/SWRL');
+const {
+  OWLClass, OWLObjectProperty, OWLDataProperty, OWLNamedIndividual
+} = require('../model/OWLEntity');
+const { OWLLiteral } = require('../model/OWLLiteral');
+const { IRI } = require('../model/IRI');
+
+const DEFAULT_PREFIXES = {
+  rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+  owl: 'http://www.w3.org/2002/07/owl#',
+  xsd: 'http://www.w3.org/2001/XMLSchema#',
+  swrlb: SWRLB_NS
+};
+
+class SWRLParser {
+  /**
+   * @param {Object} [opts]
+   * @param {Object<string,string>} [opts.prefixes] extra prefix map
+   * @param {(iri:string)=>('class'|'objectProperty'|'dataProperty'|'individual'|null)} [opts.resolve]
+   *   Resolve an entity IRI to its kind so that prop(?x,?y) can be typed.
+   */
+  constructor(opts = {}) {
+    this.prefixes = Object.assign({}, DEFAULT_PREFIXES, opts.prefixes || {});
+    this.resolve = opts.resolve || (() => null);
+  }
+
+  expandIRI(token) {
+    if (token.startsWith('<') && token.endsWith('>')) return token.slice(1, -1);
+    if (token.startsWith('http://') || token.startsWith('https://') || token.startsWith('urn:')) return token;
+    const idx = token.indexOf(':');
+    if (idx > 0) {
+      const ns = this.prefixes[token.slice(0, idx)];
+      if (ns) return ns + token.slice(idx + 1);
+    }
+    return token;
+  }
+
+  /**
+   * Parse a single SWRL rule string.
+   * @param {string} text
+   * @returns {SWRLRule}
+   */
+  parse(text) {
+    const ruleText = text.trim();
+    const arrow = ruleText.indexOf('->');
+    if (arrow < 0) throw new Error('SWRL rule missing "->": ' + ruleText);
+    const bodyText = ruleText.slice(0, arrow).trim();
+    const headText = ruleText.slice(arrow + 2).trim();
+    const body = this._parseAtomList(bodyText);
+    const head = this._parseAtomList(headText);
+    return new SWRLRule(body, head);
+  }
+
+  /** Parse several rules separated by newlines or '. ' boundaries. */
+  parseAll(text) {
+    const rules = [];
+    // Split on newlines that contain '->'
+    for (const line of text.split(/\r?\n/)) {
+      const t = line.trim();
+      if (!t || t.startsWith('#') || t.startsWith('//')) continue;
+      if (!t.includes('->')) continue;
+      rules.push(this.parse(t));
+    }
+    return rules;
+  }
+
+  _parseAtomList(text) {
+    const atoms = [];
+    // Split on '^' at top level (not inside parens/strings)
+    let depth = 0, inStr = false, cur = '';
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (ch === '"') inStr = !inStr;
+      if (!inStr && ch === '(') depth++;
+      if (!inStr && ch === ')') depth--;
+      if (!inStr && depth === 0 && ch === '^') {
+        atoms.push(this._atom(cur.trim()));
+        cur = '';
+        continue;
+      }
+      cur += ch;
+    }
+    if (cur.trim()) atoms.push(this._atom(cur.trim()));
+    return atoms;
+  }
+
+  _atom(text) {
+    const m = /^([\w:<][\w:.\-<>/]*)\(([^)]*)\)$/.exec(text.trim());
+    if (!m) throw new Error('Malformed SWRL atom: ' + text);
+    const name = m[1];
+    const args = m[2].split(',').map(s => s.trim()).filter(Boolean).map(a => this._arg(a));
+
+    const iri = this.expandIRI(name);
+    if (iri === 'http://www.w3.org/2002/07/owl#sameAs' || name === 'sameAs') {
+      return new SWRLSameAsAtom(args[0], args[1]);
+    }
+    if (iri === 'http://www.w3.org/2002/07/owl#differentFrom' || name === 'differentFrom') {
+      return new SWRLDifferentFromAtom(args[0], args[1]);
+    }
+    if (name.startsWith('swrlb:') || this.prefixes.swrlb && iri.startsWith(SWRLB_NS)) {
+      return new SWRLBuiltInAtom(IRI.create(iri), args);
+    }
+    const kind = this.resolve(iri);
+    if (kind === 'class' || (!kind && args.length === 1)) {
+      return new SWRLClassAtom(new OWLClass(iri), args[0]);
+    }
+    if (kind === 'dataProperty') {
+      return new SWRLDataPropertyAtom(new OWLDataProperty(iri), args[0], args[1]);
+    }
+    // default: object property
+    return new SWRLObjectPropertyAtom(new OWLObjectProperty(iri), args[0], args[1]);
+  }
+
+  _arg(token) {
+    if (token.startsWith('?')) return new SWRLVariable(IRI.create('urn:swrl:var:' + token.slice(1)));
+    // Literal "..."  or "..."^^dt
+    if (token.startsWith('"')) {
+      const m = /^"((?:[^"\\]|\\.)*)"(?:\^\^(.+))?$/.exec(token);
+      const lex = m ? m[1] : token.slice(1, -1);
+      let dt = null;
+      if (m && m[2]) {
+        const { OWLDatatype } = require('../model/OWLEntity');
+        dt = new OWLDatatype(this.expandIRI(m[2]));
+      }
+      return new OWLLiteral(lex, dt);
+    }
+    return new OWLNamedIndividual(this.expandIRI(token));
+  }
+}
+
+module.exports = { SWRLParser };