From 633529ca7a911646048886b7e2e0d1d98c94fdf3 Mon Sep 17 00:00:00 2001 From: Federico Igne Date: Thu, 16 Jul 2020 17:47:32 +0100 Subject: Update to JRDFox v3.1.0 --- src/main/scala/rsacomb/RDFoxAxiomConverter.scala | 4 +- .../scala/rsacomb/RDFoxClassExprConverter.scala | 14 ++--- .../scala/rsacomb/RDFoxPropertyExprConverter.scala | 5 +- src/main/scala/rsacomb/RDFoxRuleShards.scala | 4 +- src/main/scala/rsacomb/RSAComb.scala | 8 ++- src/test/scala/rsacomb/OWLAxiomSpec.scala | 60 +++++++++++----------- src/test/scala/rsacomb/OWLClassSpec.scala | 24 ++++----- 7 files changed, 62 insertions(+), 57 deletions(-) (limited to 'src') diff --git a/src/main/scala/rsacomb/RDFoxAxiomConverter.scala b/src/main/scala/rsacomb/RDFoxAxiomConverter.scala index 0a6272f..675ca7d 100644 --- a/src/main/scala/rsacomb/RDFoxAxiomConverter.scala +++ b/src/main/scala/rsacomb/RDFoxAxiomConverter.scala @@ -3,8 +3,8 @@ package rsacomb import org.semanticweb.owlapi.model.{OWLAxiom, OWLSubClassOfAxiom, OWLEquivalentClassesAxiom} import org.semanticweb.owlapi.model.OWLAxiomVisitorEx -import tech.oxfordsemantic.jrdfox.logic.Rule -import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Literal, Individual} +import tech.oxfordsemantic.jrdfox.logic.{Rule, BodyFormula} +import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Literal} import scala.collection.JavaConverters._ diff --git a/src/main/scala/rsacomb/RDFoxClassExprConverter.scala b/src/main/scala/rsacomb/RDFoxClassExprConverter.scala index 3e60461..bf026c3 100644 --- a/src/main/scala/rsacomb/RDFoxClassExprConverter.scala +++ b/src/main/scala/rsacomb/RDFoxClassExprConverter.scala @@ -5,8 +5,8 @@ import java.util.stream.{Stream,Collectors} import org.semanticweb.owlapi.model.{OWLClassExpression, OWLClass, OWLObjectSomeValuesFrom, OWLObjectIntersectionOf, OWLObjectOneOf, OWLObjectMaxCardinality} import org.semanticweb.owlapi.model.OWLClassExpressionVisitorEx -import tech.oxfordsemantic.jrdfox.logic.{AtomicFormula, Bind,BuiltinFunctionCall} -import tech.oxfordsemantic.jrdfox.logic.{Atom, Predicate, Term, Variable, Literal, Individual} +import tech.oxfordsemantic.jrdfox.logic.{BindAtom, BuiltinFunctionCall, TupleTableName} +import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Variable, Literal, Datatype} import rsacomb.SkolemStrategy import rsacomb.RDFoxRuleShards @@ -39,7 +39,7 @@ class RDFoxClassExprConverter(term : Term, skolem : SkolemStrategy) override def visit(expr : OWLClass) : RDFoxRuleShards = { val name = expr.getIRI.getIRIString - val atom = List(Atom.create(Predicate.create(name), term)) + val atom = List(Atom.create(TupleTableName.create(name), term)) RDFoxRuleShards(atom,List()) } @@ -64,7 +64,7 @@ class RDFoxClassExprConverter(term : Term, skolem : SkolemStrategy) .head // restricts to proper "nominals" .asOWLNamedIndividual.getIRI.getIRIString val atom = List(Atom.create( - Predicate.create("owl:sameAs"), term, Individual.create(ind) + TupleTableName.create("owl:sameAs"), term, Literal.create(ind, Datatype.IRI_REFERENCE) )) RDFoxRuleShards(atom,List()) } @@ -77,12 +77,12 @@ class RDFoxClassExprConverter(term : Term, skolem : SkolemStrategy) val y = Variable.create("y") val (fun,term1) = skolem match { case SkolemStrategy.None => (List(),y) - case SkolemStrategy.Constant(c) => (List(), Individual.create(c)) + case SkolemStrategy.Constant(c) => (List(), Literal.create(c, Datatype.IRI_REFERENCE)) case SkolemStrategy.Standard(f) => // At the time of writing the RDFox library does not have a // particular class for the "SKOLEM" operator and it is instead // a simple builtin function with a special name. - (List(Bind.create(BuiltinFunctionCall.create("SKOLEM",term),y)),y) + (List(BindAtom.create(BuiltinFunctionCall.create("SKOLEM",term),y)),y) } val classVisitor = new RDFoxClassExprConverter(term1,skolem) val classResult = expr.getFiller.accept(classVisitor) @@ -108,7 +108,7 @@ class RDFoxClassExprConverter(term : Term, skolem : SkolemStrategy) .map(expr.getProperty.accept(_)) .flatten RDFoxRuleShards( - List(Atom.create(Predicate.create("owl:sameAs"),vars(0),vars(1))), + List(Atom.create(TupleTableName.create("owl:sameAs"),vars(0),vars(1))), classResult.res ++ propertyResult ) } diff --git a/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala b/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala index 2885ed9..8d472bf 100644 --- a/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala +++ b/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala @@ -3,7 +3,8 @@ package rsacomb import org.semanticweb.owlapi.model.{OWLPropertyExpression, OWLObjectProperty} import org.semanticweb.owlapi.model.OWLPropertyExpressionVisitorEx -import tech.oxfordsemantic.jrdfox.logic.{Atom, Predicate, Term, Variable, Literal} +import tech.oxfordsemantic.jrdfox.logic.{TupleTableName} +import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Variable, Literal} import rsacomb.SkolemStrategy @@ -14,7 +15,7 @@ class RDFoxPropertyExprConverter(term1 : Term, term2 : Term, skolem : SkolemStra override def visit(expr : OWLObjectProperty) : List[Atom] = { val name = expr.getIRI.getIRIString - List(Atom.create(Predicate.create(name), term1, term2)) + List(Atom.create(TupleTableName.create(name), term1, term2)) } def doDefault(expr : OWLPropertyExpression) : List[Atom] = List() diff --git a/src/main/scala/rsacomb/RDFoxRuleShards.scala b/src/main/scala/rsacomb/RDFoxRuleShards.scala index bce31d2..8f72983 100644 --- a/src/main/scala/rsacomb/RDFoxRuleShards.scala +++ b/src/main/scala/rsacomb/RDFoxRuleShards.scala @@ -1,6 +1,6 @@ package rsacomb -import tech.oxfordsemantic.jrdfox.logic.{Rule, Atom, Literal} +import tech.oxfordsemantic.jrdfox.logic.{Atom, BodyFormula} -case class RDFoxRuleShards(res : List[Atom], ext : List[Literal]) +case class RDFoxRuleShards(res : List[Atom], ext : List[BodyFormula]) diff --git a/src/main/scala/rsacomb/RSAComb.scala b/src/main/scala/rsacomb/RSAComb.scala index bc94a8d..16d7a04 100644 --- a/src/main/scala/rsacomb/RSAComb.scala +++ b/src/main/scala/rsacomb/RSAComb.scala @@ -15,8 +15,9 @@ import org.semanticweb.owlapi.model.parameters.Imports import tech.oxfordsemantic.jrdfox.Prefixes import tech.oxfordsemantic.jrdfox.client.{ConnectionFactory, ServerConnection, DataStoreConnection} import tech.oxfordsemantic.jrdfox.client.UpdateType -import tech.oxfordsemantic.jrdfox.logic.{Rule, Atom, Literal, Predicate, Term, Variable} -import tech.oxfordsemantic.jrdfox.logic.{Bind, BuiltinFunctionCall} +import tech.oxfordsemantic.jrdfox.logic.{Rule, Atom, Literal, Term, Variable} +import tech.oxfordsemantic.jrdfox.logic.{BuiltinFunctionCall, TupleTableName} +import tech.oxfordsemantic.jrdfox.logic.{LogicFormat} import scala.collection.JavaConverters._ @@ -46,6 +47,9 @@ object RSA { * 2) call RDFox on the onto and compute materialization * 3) build graph from E(x,y) facts * 4) check if the graph is tree-like + * ideally this annotates the graph with info about the reasons + * why the ontology might not be RSA. This could help a second + * step of approximation of an Horn-ALCHOIQ to RSA */ /* Ontology axiom convertion into LP rules */ diff --git a/src/test/scala/rsacomb/OWLAxiomSpec.scala b/src/test/scala/rsacomb/OWLAxiomSpec.scala index b6a44f4..8238536 100644 --- a/src/test/scala/rsacomb/OWLAxiomSpec.scala +++ b/src/test/scala/rsacomb/OWLAxiomSpec.scala @@ -8,8 +8,8 @@ import uk.ac.manchester.cs.owl.owlapi.{OWLClassImpl, OWLObjectSomeValuesFromImpl import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl} import org.semanticweb.owlapi.model.{OWLAxiom,IRI} -import tech.oxfordsemantic.jrdfox.logic.{Rule,Bind,BuiltinFunctionCall} -import tech.oxfordsemantic.jrdfox.logic.{Atom, Predicate, Term, Variable, Individual} +import tech.oxfordsemantic.jrdfox.logic.{Rule,BindAtom,BuiltinFunctionCall} +import tech.oxfordsemantic.jrdfox.logic.{Atom, TupleTableName, Term, Variable, Literal, Datatype} object OWLAxiomSpec { @@ -28,14 +28,14 @@ object OWLAxiomSpec { val term_x = Variable.create("x") val term_y = Variable.create("y") val term_z = Variable.create("z") - val term_c1 = Individual.create("internal:c_1") - val term_c2 = Individual.create("internal:c_2") - val term_alice = Individual.create("univ:alice") + val term_c1 = Literal.create("internal:c_1", Datatype.IRI_REFERENCE) + val term_c2 = Literal.create("internal:c_2", Datatype.IRI_REFERENCE) + val term_alice = Literal.create("univ:alice", Datatype.IRI_REFERENCE) // RDFox Predicates - val pred_sameAs = Predicate.create("owl:sameAs") - val pred_Professor = Predicate.create(iri_Professor.getIRIString) - val pred_hasSupervisor = Predicate.create(iri_hasSupervisor.getIRIString) + val pred_sameAs = TupleTableName.create("owl:sameAs") + val pred_Professor = TupleTableName.create(iri_Professor.getIRIString) + val pred_hasSupervisor = TupleTableName.create(iri_hasSupervisor.getIRIString) // OWL Classes // Name Class corresponding to @@ -164,15 +164,15 @@ class OWLAxiomSpec it should "contain a conjuction of atoms (Student[?x],Worker[?x]) in the body of the rule" in { val result = convertAxiom(axiom_OWLSubClassOf1,term_x) val body = List( - Atom.create(Predicate.create(iri_Student.getIRIString),term_x), - Atom.create(Predicate.create(iri_Worker.getIRIString),term_x) + Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x), + Atom.create(TupleTableName.create(iri_Worker.getIRIString),term_x) ) result.loneElement.getBody should contain theSameElementsAs body } it should "contain a single atom (PartTimeStudent[?x]) in the head of the rule" in { val result = convertAxiom(axiom_OWLSubClassOf1,term_x) - val head = Atom.create(Predicate.create(iri_PartTimeStudent.getIRIString),term_x) + val head = Atom.create(TupleTableName.create(iri_PartTimeStudent.getIRIString),term_x) result.loneElement.getHead.loneElement should be (head) } @@ -188,17 +188,17 @@ class OWLAxiomSpec it should "contain a single atom (Student[?x]) in the body of the rule" in { val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString) val result = convertAxiom(axiom_OWLSubClassOf2,term_x,skolem) - val body = Atom.create(Predicate.create(iri_Student.getIRIString),term_x) + val body = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x) result.loneElement.getBody.loneElement should equal (body) } it should "contain a conjuction of atoms (hasSupervisor[?x,?c],Professor[?c]) in the head of the rule" in { val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString) val result = convertAxiom(axiom_OWLSubClassOf2,term_x,skolem) - val term_c = Individual.create(skolem.const) + val term_c = Literal.create(skolem.const, Datatype.IRI_REFERENCE) val head = List( - Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_c), - Atom.create(Predicate.create(iri_Professor.getIRIString),term_c) + Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_c), + Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_c) ) result.loneElement.getHead should contain theSameElementsAs (head) } @@ -215,14 +215,14 @@ class OWLAxiomSpec it should "contain an atom (Student[?x]) in the body of the rule" in { val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) - val body = Atom.create(Predicate.create(iri_Student.getIRIString),term_x) + val body = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x) result.loneElement.getBody should contain (body) } it should "contain a built-in function call (BIND(?y,SKOLEM(?f,?x))) in the body of the rule" in { val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) - val call = Bind.create(BuiltinFunctionCall.create("SKOLEM",term_x),term_y) + val call = BindAtom.create(BuiltinFunctionCall.create("SKOLEM",term_x),term_y) result.loneElement.getBody should contain (call) } @@ -230,8 +230,8 @@ class OWLAxiomSpec val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) val head = List( - Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_y), - Atom.create(Predicate.create(iri_Professor.getIRIString),term_y) + Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_y), + Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_y) ) result.loneElement.getHead should contain theSameElementsAs head } @@ -245,15 +245,15 @@ class OWLAxiomSpec it should "contain a conjunction of atoms (hasSupervisor[?x,?y],Professor[?y]) in the body of the rule" in { val result = convertAxiom(axiom_OWLSubClassOf3,term_x) val body = List( - Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_y), - Atom.create(Predicate.create(iri_Professor.getIRIString),term_y) + Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_y), + Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_y) ) result.loneElement.getBody should contain theSameElementsAs body } it should "contain a single atom (Student[?x]) in the head of the rule" in { val result = convertAxiom(axiom_OWLSubClassOf3, term_x) - val head = Atom.create(Predicate.create(iri_Student.getIRIString),term_x) + val head = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x) result.loneElement.getHead.loneElement should be (head) } @@ -265,13 +265,13 @@ class OWLAxiomSpec it should "contain a single atoms (Student[?x]) in the body of the rule" in { val result = convertAxiom(axiom_OWLSubClassOf4,term_x) - val body = Atom.create(Predicate.create(iri_Student.getIRIString),term_x) + val body = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x) result.loneElement.getBody.loneElement should be (body) } it should "contain a single atom (sameAs[?x,alice])) in the head of the rule" in { val result = convertAxiom(axiom_OWLSubClassOf4, term_x) - val head = Atom.create(Predicate.create(iri_sameAs.getIRIString),term_x,term_alice) + val head = Atom.create(TupleTableName.create(iri_sameAs.getIRIString),term_x,term_alice) result.loneElement.getHead.loneElement should be (head) } @@ -284,18 +284,18 @@ class OWLAxiomSpec it should "contain a conjunction of atoms (...) in the body of the rule" in { val result = convertAxiom(axiom_OWLSubClassOf5,term_x) val body = List( - Atom.create(Predicate.create(iri_Student.getIRIString),term_x), - Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_y), - Atom.create(Predicate.create(iri_Professor.getIRIString),term_y), - Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_z), - Atom.create(Predicate.create(iri_Professor.getIRIString),term_z) + Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x), + Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_y), + Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_y), + Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_z), + Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_z) ) result.loneElement.getBody should contain theSameElementsAs body } it should "contain a single atom (sameAs[?x,?z])) in the head of the rule" in { val result = convertAxiom(axiom_OWLSubClassOf5, term_x) - val head = Atom.create(Predicate.create(iri_sameAs.getIRIString),term_y,term_z) + val head = Atom.create(TupleTableName.create(iri_sameAs.getIRIString),term_y,term_z) result.loneElement.getHead.loneElement should be (head) } diff --git a/src/test/scala/rsacomb/OWLClassSpec.scala b/src/test/scala/rsacomb/OWLClassSpec.scala index df10e19..98e14cf 100644 --- a/src/test/scala/rsacomb/OWLClassSpec.scala +++ b/src/test/scala/rsacomb/OWLClassSpec.scala @@ -6,8 +6,8 @@ import uk.ac.manchester.cs.owl.owlapi.{OWLClassImpl, OWLObjectSomeValuesFromImpl import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl} import org.semanticweb.owlapi.model.IRI -import tech.oxfordsemantic.jrdfox.logic.{Bind,BuiltinFunctionCall} -import tech.oxfordsemantic.jrdfox.logic.{Atom, Predicate, Term, Variable, Individual} +import tech.oxfordsemantic.jrdfox.logic.{BindAtom,BuiltinFunctionCall} +import tech.oxfordsemantic.jrdfox.logic.{Atom, TupleTableName, Term, Variable, Literal, Datatype} import rsacomb.RDFoxRuleShards @@ -25,14 +25,14 @@ object OWLClassSpec { // RDFox Terms val term_x = Variable.create("x") val term_y = Variable.create("y") - val term_c1 = Individual.create("internal:c_1") - val term_c2 = Individual.create("internal:c_2") - val term_alice = Individual.create("univ:alice") + val term_c1 = Literal.create("internal:c_1", Datatype.IRI_REFERENCE) + val term_c2 = Literal.create("internal:c_2", Datatype.IRI_REFERENCE) + val term_alice = Literal.create("univ:alice", Datatype.IRI_REFERENCE) // RDFox Predicates - val pred_sameAs = Predicate.create("owl:sameAs") - val pred_Professor = Predicate.create(iri_Professor.getIRIString) - val pred_hasSupervisor = Predicate.create(iri_hasSupervisor.getIRIString) + val pred_sameAs = TupleTableName.create("owl:sameAs") + val pred_Professor = TupleTableName.create(iri_Professor.getIRIString) + val pred_hasSupervisor = TupleTableName.create(iri_hasSupervisor.getIRIString) // OWL Classes // Name Class corresponding to @@ -135,7 +135,7 @@ class OWLClassSpec it should "be converted into a single Atom" in { val visitor = RDFoxClassExprConverter(term_x) val result = class_OWLObjectOneOf.accept(visitor) - result.res.loneElement should (be (a [Atom]) and have ('predicate (pred_sameAs))) + result.res.loneElement should (be (a [Atom]) and have ('tupleTableName (pred_sameAs))) } it should "have an empty extension list" in { @@ -196,8 +196,8 @@ class OWLClassSpec val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString) val visitor = RDFoxClassExprConverter(term_x,skolem) val result = class_OWLObjectSomeValuesFrom.accept(visitor) - result.ext.loneElement shouldBe a [Bind] - val builtin = result.ext.head.asInstanceOf[Bind].getBuiltinExpression + result.ext.loneElement shouldBe a [BindAtom] + val builtin = result.ext.head.asInstanceOf[BindAtom].getBuiltinExpression builtin should (be (a [BuiltinFunctionCall]) and have ('functionName ("SKOLEM"))) } @@ -241,7 +241,7 @@ class OWLClassSpec it should "have a single Atom in the result list" in { val visitor = RDFoxClassExprConverter(term_x) val result = class_OWLObjectMaxCardinality.accept(visitor) - result.res.loneElement should (be (an [Atom]) and have ('predicate (pred_sameAs))) + result.res.loneElement should (be (an [Atom]) and have ('tupleTableName (pred_sameAs))) } it should "have two unary Atoms in its extension list" in { -- cgit v1.2.3