From 0eca2d66ecf1aaca6f508bc14738d9ef3cc2de20 Mon Sep 17 00:00:00 2001
From: Federico Igne <federico.igne@cs.ox.ac.uk>
Date: Tue, 24 Nov 2020 11:48:54 +0000
Subject: Rename `RDFoxHelpers` to `RDFoxUtil`

For a more consistent naming.
---
 .../uk/ac/ox/cs/rsacomb/FilteringProgram.scala     |   4 +-
 src/main/scala/uk/ac/ox/cs/rsacomb/Main.scala      |   2 +-
 .../scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala    |  22 +--
 .../ac/ox/cs/rsacomb/sparql/ConjunctiveQuery.scala |   4 +-
 .../uk/ac/ox/cs/rsacomb/util/RDFoxHelpers.scala    | 219 ---------------------
 .../scala/uk/ac/ox/cs/rsacomb/util/RDFoxUtil.scala | 219 +++++++++++++++++++++
 .../uk/ac/ox/cs/rsacomb/CanonicalModelSpec.scala   |   2 +-
 7 files changed, 236 insertions(+), 236 deletions(-)
 delete mode 100644 src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxHelpers.scala
 create mode 100644 src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxUtil.scala

diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/FilteringProgram.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/FilteringProgram.scala
index b70de66..b07ba92 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/FilteringProgram.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/FilteringProgram.scala
@@ -12,7 +12,7 @@ import tech.oxfordsemantic.jrdfox.logic.expression.{Term, Variable}
 import uk.ac.ox.cs.rsacomb.implicits.RSAAtom
 import uk.ac.ox.cs.rsacomb.sparql.ConjunctiveQuery
 import uk.ac.ox.cs.rsacomb.suffix.{Forward, Backward}
-import uk.ac.ox.cs.rsacomb.util.{RSA, RDFoxHelpers}
+import uk.ac.ox.cs.rsacomb.util.{RSA, RDFoxUtil}
 
 /** Factory for [[uk.ac.ox.cs.rsacomb.FilteringProgram FilteringProgram]] */
 object FilteringProgram {
@@ -310,7 +310,7 @@ class FilteringProgram(query: ConjunctiveQuery, constants: List[Term])
         r5a ::: r5b ::: r5c :::
         r6 ::: r7b ::: r7a :::
         r8a ::: r8b :: r8c :::
-        r9 :: List()) map RDFoxHelpers.reify
+        r9 :: List()) map RDFoxUtil.reify
     }
 
   /** Pretty-print filtering rule */
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/Main.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/Main.scala
index 678a5fa..016bb86 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/Main.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/Main.scala
@@ -10,7 +10,7 @@ import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
 import tech.oxfordsemantic.jrdfox.logic.expression.{IRI, Term}
 
 /* Local imports */
-import util.{RDFoxHelpers, RSA}
+import util.{RDFoxUtil, RSA}
 import sparql.ConjunctiveQuery
 
 object RSAComb extends App {
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
index 24045de..19a6280 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
@@ -52,7 +52,7 @@ import uk.ac.ox.cs.rsacomb.converter.{RDFoxAxiomConverter, SkolemStrategy}
 import uk.ac.ox.cs.rsacomb.implicits.RSAAxiom
 import uk.ac.ox.cs.rsacomb.suffix._
 import uk.ac.ox.cs.rsacomb.sparql._
-import uk.ac.ox.cs.rsacomb.util.{RDFoxHelpers, RSA}
+import uk.ac.ox.cs.rsacomb.util.{RDFoxUtil, RSA}
 
 object RSAOntology {
 
@@ -166,7 +166,7 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
     //datalog.foreach(println)
 
     // Open connection with RDFox
-    val (server, data) = RDFoxHelpers.openConnection("RSACheck")
+    val (server, data) = RDFoxUtil.openConnection("RSACheck")
     // Add Data (hardcoded for now)
     //data.importData(UpdateType.ADDITION, RSA.Prefixes, ":a a :A .")
 
@@ -196,7 +196,7 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
     //println(graph)
 
     // Close connection to RDFox
-    RDFoxHelpers.closeConnection(server, data)
+    RDFoxUtil.closeConnection(server, data)
 
     /* To check if the graph is tree-like we check for acyclicity in a
      * undirected graph.
@@ -263,7 +263,7 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
       data: DataStoreConnection
   ): Graph[Resource, UnDiEdge] = {
     val query = "SELECT ?X ?Y WHERE { ?X rsa:E ?Y }"
-    val answers = RDFoxHelpers.submitQuery(data, query, RSA.Prefixes).get
+    val answers = RDFoxUtil.submitQuery(data, query, RSA.Prefixes).get
     var edges: Seq[UnDiEdge[Resource]] = answers.map {
       case Seq(n1, n2) => UnDiEdge(n1, n2)
     }
@@ -306,20 +306,20 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
     */
   def ask(query: ConjunctiveQuery): ConjunctiveQueryAnswers = {
     import implicits.JavaCollections._
-    val (server, data) = RDFoxHelpers.openConnection(RSAOntology.DataStore)
+    val (server, data) = RDFoxUtil.openConnection(RSAOntology.DataStore)
     data.addRules(this.canonicalModel.rules)
     data.addRules(this.filteringProgram(query).rules)
-    val answers = RDFoxHelpers
+    val answers = RDFoxUtil
       .submitQuery(
         data,
-        RDFoxHelpers.buildDescriptionQuery("Ans", query.answer.size),
+        RDFoxUtil.buildDescriptionQuery("Ans", query.answer.size),
         RSA.Prefixes
       )
       .map(
         new ConjunctiveQueryAnswers(query.bcq, _)
       )
       .get
-    RDFoxHelpers.closeConnection(server, data)
+    RDFoxUtil.closeConnection(server, data)
     answers
   }
 
@@ -343,9 +343,9 @@ class RSAOntology(val ontology: OWLOntology) extends RSAAxiom {
       prefixes: Prefixes = new Prefixes(),
       opts: ju.Map[String, String] = new ju.HashMap[String, String]()
   ): Option[Seq[Seq[Resource]]] = {
-    val (server, data) = RDFoxHelpers.openConnection(RSAOntology.DataStore)
-    val answers = RDFoxHelpers.submitQuery(data, query, prefixes, opts)
-    RDFoxHelpers.closeConnection(server, data)
+    val (server, data) = RDFoxUtil.openConnection(RSAOntology.DataStore)
+    val answers = RDFoxUtil.submitQuery(data, query, prefixes, opts)
+    RDFoxUtil.closeConnection(server, data)
     answers
   }
 
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuery.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuery.scala
index 59eb626..bc90c86 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuery.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/sparql/ConjunctiveQuery.scala
@@ -11,7 +11,7 @@ import tech.oxfordsemantic.jrdfox.logic.sparql.pattern.{
   TriplePattern
 }
 import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
-import uk.ac.ox.cs.rsacomb.util.RDFoxHelpers
+import uk.ac.ox.cs.rsacomb.util.RDFoxUtil
 
 /** Factory for [[uk.ac.ox.cs.rsacomb.sparql.ConjunctiveQuery]]. */
 object ConjunctiveQuery {
@@ -35,7 +35,7 @@ object ConjunctiveQuery {
       query: String,
       prefixes: Prefixes = new Prefixes()
   ): Option[ConjunctiveQuery] =
-    RDFoxHelpers.parseSelectQuery(query, prefixes).map(ConjunctiveQuery(_))
+    RDFoxUtil.parseSelectQuery(query, prefixes).map(ConjunctiveQuery(_))
 
 }
 
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxHelpers.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxHelpers.scala
deleted file mode 100644
index a05e416..0000000
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxHelpers.scala
+++ /dev/null
@@ -1,219 +0,0 @@
-package uk.ac.ox.cs.rsacomb.util
-
-import java.io.StringReader
-import tech.oxfordsemantic.jrdfox.Prefixes
-import tech.oxfordsemantic.jrdfox.client.{
-  ConnectionFactory,
-  ServerConnection,
-  DataStoreConnection
-}
-import tech.oxfordsemantic.jrdfox.formats.SPARQLParser
-import tech.oxfordsemantic.jrdfox.logic.datalog.{
-  Rule,
-  BodyFormula,
-  Negation,
-  TupleTableAtom,
-  TupleTableName
-}
-import tech.oxfordsemantic.jrdfox.logic.expression.{Resource}
-import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
-import uk.ac.ox.cs.rsacomb.suffix.Nth
-import uk.ac.ox.cs.rsacomb.implicits.RSAAtom
-
-/** A collection of helper methods for RDFox */
-object RDFoxHelpers extends RSAAtom {
-
-  /** Simplify conversion between Java and Scala `List`s */
-  import uk.ac.ox.cs.rsacomb.implicits.JavaCollections._
-
-  /** Extends capabilities of
-    *  [[tech.oxfordsemantic.jrdfox.logic.datalog.TupleTableAtom TupleTableAtom]].
-    */
-  //import uk.ac.ox.cs.rsacomb.implicits.RSAAtom._
-
-  /** Type alias for a collection of answers to a
-    * [[tech.oxfordsemantic.jrdfox.logic.sparql.statement.Query]].
-    */
-  private type QueryAnswers = Seq[Seq[Resource]]
-  private def QueryAnswers() = List.empty[Seq[Resource]]
-
-  /** Type alias for <option => value> RDFox options. */
-  private type RDFoxOpts = java.util.Map[String, String]
-  private def RDFoxOpts() = new java.util.HashMap[String, String]()
-
-  /** Setup a new local connection with RDFox.
-    *
-    * @param dataStore data store identifier
-    * @param opts additional options to RDFox
-    * @return a tuple with the newly opened server and data store
-    * connections.
-    *
-    * @see [[uk.ac.ox.cs.rsacomb.util.RDFoxHelpers.closeConnection
-    * RDFoxHelpers.closeConnection]] for
-    * details on how to close an open connection.
-    */
-  def openConnection(
-      datastore: String,
-      opts: RDFoxOpts = RDFoxOpts()
-  ): (ServerConnection, DataStoreConnection) = {
-    val serverUrl = "rdfox:local"
-    val role = ""
-    val password = ""
-    val server =
-      ConnectionFactory.newServerConnection(serverUrl, role, password)
-    if (!server.containsDataStore(datastore))
-      server.createDataStore(datastore, "par-complex-nn", opts)
-    val data = server.newDataStoreConnection(datastore)
-    (server, data)
-  }
-
-  /** Parse a SELECT query from a string in SPARQL format.
-    *
-    * @param query the string containing the SPARQL query
-    * @param prefixes additional prefixes for the query. It defaults to
-    * an empty set.
-    * @return a [[tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery SelectQuery]]
-    * if the input string is a SELECT query, none otherwise.
-    */
-  def parseSelectQuery(
-      query: String,
-      prefixes: Prefixes = new Prefixes()
-  ): Option[SelectQuery] = {
-    val parser = new SPARQLParser(
-      prefixes,
-      new StringReader(query)
-    )
-    parser.parseSingleQuery() match {
-      case q: SelectQuery => Some(q)
-      case _              => None
-    }
-  }
-
-  /** Execute a query over a given datastore connection.
-    *
-    * @param data RDFox datastore connection.
-    * @param query a
-    * [[tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery SelectQuery]]
-    * to be executed.
-    * @param opts additional options to RDFox.
-    * @returns a collection of answers to the query.
-    */
-  def submitSelectQuery(
-      data: DataStoreConnection,
-      query: SelectQuery,
-      opts: RDFoxOpts = RDFoxOpts()
-  ): QueryAnswers = {
-    val cursor = data.createCursor(query, opts)
-    var answers = QueryAnswers()
-    var mul = cursor.open()
-    while (mul > 0) {
-      val answer =
-        (0 until cursor.getArity).map(cursor.getResource(_)).toList
-      answers = answer :: answers
-      mul = cursor.advance()
-    }
-    cursor.close();
-    answers
-  }
-
-  /** Execute a query over a given datastore connection.
-    *
-    * @param data RDFox datastore connection.
-    * @param query a string representing a SPARQL query.
-    * @param prefixes additional prefixes for the query. It defaults to
-    * an empty set.
-    * @param opts additional options to RDFox.
-    * @returns a collection of answers to the query if the input query
-    * is a SELECT query, none otherwise.
-    */
-  def submitQuery(
-      data: DataStoreConnection,
-      query: String,
-      prefixes: Prefixes = new Prefixes(),
-      opts: RDFoxOpts = RDFoxOpts()
-  ): Option[QueryAnswers] =
-    parseSelectQuery(query, prefixes).map(submitSelectQuery(data, _, opts))
-
-  /** Returns a query describing an internal predicate.
-    *
-    * In the RSA combined approach internal predicates are reified to be
-    * compatible with RDFox engine. This helper allows to build a query
-    * to gather all instances of an internal predicate
-    *
-    * @param pred name of the predicate to describe.
-    * @param arity arity of the predicate.
-    * @return a string containing a SPARQL query.
-    */
-  def buildDescriptionQuery(
-      pred: String,
-      arity: Int
-  ): String = {
-    if (arity > 0) {
-      (0 until arity).mkString("SELECT ?X", " ?X", "\n") +
-        (0 until arity)
-          .map(i => s"?S rsa:${pred :: Nth(i)} ?X$i .")
-          .mkString("WHERE {\n", "\n", "\n}")
-    } else {
-      s"ASK { ?X a rsa:$pred }"
-    }
-  }
-
-  /** Reify a [[tech.oxfordsemantic.jrdfox.logic.datalog.Rule Rule]].
-    *
-    * This is needed because RDFox supports only predicates of arity 1
-    * or 2, but the filtering program uses predicates with higher arity.
-    *
-    * @note we can perform a reification of the atoms thanks to the
-    * built-in `SKOLEM` funtion of RDFox.
-    */
-  def reify(rule: Rule): Rule = {
-    val (bs, as) = rule.getHead.map(_.reified).unzip
-    val head: List[TupleTableAtom] = as.flatten
-    val bind: List[BodyFormula] = bs.flatten
-    val body: List[BodyFormula] = rule.getBody.map(reify).flatten
-    Rule.create(head, bind ::: body)
-  }
-
-  /** Reify a [[tech.oxfordsemantic.jrdfox.logic.datalog.BodyFormula BodyFormula]].
-    *
-    * This is needed because RDFox supports only predicates of arity 1
-    * or 2, but the filtering program uses predicates with higher arity.
-    *
-    * @note we can perform a reification of the atoms thanks to the
-    * built-in `SKOLEM` funtion of RDFox.
-    */
-  private def reify(formula: BodyFormula): List[BodyFormula] = {
-    formula match {
-      case atom: TupleTableAtom => atom.reified._2
-      case neg: Negation => {
-        val (bs, as) = neg.getNegatedAtoms
-          .map({
-            case a: TupleTableAtom => a.reified
-            case a                 => (None, List(a))
-          })
-          .unzip
-        val bind = bs.flatten.map(_.getBoundVariable)
-        val atoms = as.flatten
-        List(Negation.create(bind, atoms))
-      }
-      case other => List(other)
-    }
-  }
-
-  /** Close an open connection to RDFox.
-    *
-    * @param server server connection
-    * @param data data store connections
-    *
-    * @see [[uk.ac.ox.cs.rsacomb.util.RDFoxHelpers.openConnection RDFoxHelpers.openConnection]]
-    * for details on how to create a new connection with RDFox.
-    */
-  def closeConnection(
-      server: ServerConnection,
-      data: DataStoreConnection
-  ): Unit = {
-    data.close();
-    server.close();
-  }
-
-}
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxUtil.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxUtil.scala
new file mode 100644
index 0000000..99a9614
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxUtil.scala
@@ -0,0 +1,219 @@
+package uk.ac.ox.cs.rsacomb.util
+
+import java.io.StringReader
+import tech.oxfordsemantic.jrdfox.Prefixes
+import tech.oxfordsemantic.jrdfox.client.{
+  ConnectionFactory,
+  ServerConnection,
+  DataStoreConnection
+}
+import tech.oxfordsemantic.jrdfox.formats.SPARQLParser
+import tech.oxfordsemantic.jrdfox.logic.datalog.{
+  Rule,
+  BodyFormula,
+  Negation,
+  TupleTableAtom,
+  TupleTableName
+}
+import tech.oxfordsemantic.jrdfox.logic.expression.{Resource}
+import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
+import uk.ac.ox.cs.rsacomb.suffix.Nth
+import uk.ac.ox.cs.rsacomb.implicits.RSAAtom
+
+/** A collection of helper methods for RDFox */
+object RDFoxUtil extends RSAAtom {
+
+  /** Simplify conversion between Java and Scala `List`s */
+  import uk.ac.ox.cs.rsacomb.implicits.JavaCollections._
+
+  /** Extends capabilities of
+    *  [[tech.oxfordsemantic.jrdfox.logic.datalog.TupleTableAtom TupleTableAtom]].
+    */
+  //import uk.ac.ox.cs.rsacomb.implicits.RSAAtom._
+
+  /** Type alias for a collection of answers to a
+    * [[tech.oxfordsemantic.jrdfox.logic.sparql.statement.Query]].
+    */
+  private type QueryAnswers = Seq[Seq[Resource]]
+  private def QueryAnswers() = List.empty[Seq[Resource]]
+
+  /** Type alias for <option => value> RDFox options. */
+  private type RDFoxOpts = java.util.Map[String, String]
+  private def RDFoxOpts() = new java.util.HashMap[String, String]()
+
+  /** Setup a new local connection with RDFox.
+    *
+    * @param dataStore data store identifier
+    * @param opts additional options to RDFox
+    * @return a tuple with the newly opened server and data store
+    * connections.
+    *
+    * @see [[uk.ac.ox.cs.rsacomb.util.RDFoxUtil.closeConnection
+    * RDFoxUtil.closeConnection]] for
+    * details on how to close an open connection.
+    */
+  def openConnection(
+      datastore: String,
+      opts: RDFoxOpts = RDFoxOpts()
+  ): (ServerConnection, DataStoreConnection) = {
+    val serverUrl = "rdfox:local"
+    val role = ""
+    val password = ""
+    val server =
+      ConnectionFactory.newServerConnection(serverUrl, role, password)
+    if (!server.containsDataStore(datastore))
+      server.createDataStore(datastore, "par-complex-nn", opts)
+    val data = server.newDataStoreConnection(datastore)
+    (server, data)
+  }
+
+  /** Parse a SELECT query from a string in SPARQL format.
+    *
+    * @param query the string containing the SPARQL query
+    * @param prefixes additional prefixes for the query. It defaults to
+    * an empty set.
+    * @return a [[tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery SelectQuery]]
+    * if the input string is a SELECT query, none otherwise.
+    */
+  def parseSelectQuery(
+      query: String,
+      prefixes: Prefixes = new Prefixes()
+  ): Option[SelectQuery] = {
+    val parser = new SPARQLParser(
+      prefixes,
+      new StringReader(query)
+    )
+    parser.parseSingleQuery() match {
+      case q: SelectQuery => Some(q)
+      case _              => None
+    }
+  }
+
+  /** Execute a query over a given datastore connection.
+    *
+    * @param data RDFox datastore connection.
+    * @param query a
+    * [[tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery SelectQuery]]
+    * to be executed.
+    * @param opts additional options to RDFox.
+    * @returns a collection of answers to the query.
+    */
+  def submitSelectQuery(
+      data: DataStoreConnection,
+      query: SelectQuery,
+      opts: RDFoxOpts = RDFoxOpts()
+  ): QueryAnswers = {
+    val cursor = data.createCursor(query, opts)
+    var answers = QueryAnswers()
+    var mul = cursor.open()
+    while (mul > 0) {
+      val answer =
+        (0 until cursor.getArity).map(cursor.getResource(_)).toList
+      answers = answer :: answers
+      mul = cursor.advance()
+    }
+    cursor.close();
+    answers
+  }
+
+  /** Execute a query over a given datastore connection.
+    *
+    * @param data RDFox datastore connection.
+    * @param query a string representing a SPARQL query.
+    * @param prefixes additional prefixes for the query. It defaults to
+    * an empty set.
+    * @param opts additional options to RDFox.
+    * @returns a collection of answers to the query if the input query
+    * is a SELECT query, none otherwise.
+    */
+  def submitQuery(
+      data: DataStoreConnection,
+      query: String,
+      prefixes: Prefixes = new Prefixes(),
+      opts: RDFoxOpts = RDFoxOpts()
+  ): Option[QueryAnswers] =
+    parseSelectQuery(query, prefixes).map(submitSelectQuery(data, _, opts))
+
+  /** Returns a query describing an internal predicate.
+    *
+    * In the RSA combined approach internal predicates are reified to be
+    * compatible with RDFox engine. This helper allows to build a query
+    * to gather all instances of an internal predicate
+    *
+    * @param pred name of the predicate to describe.
+    * @param arity arity of the predicate.
+    * @return a string containing a SPARQL query.
+    */
+  def buildDescriptionQuery(
+      pred: String,
+      arity: Int
+  ): String = {
+    if (arity > 0) {
+      (0 until arity).mkString("SELECT ?X", " ?X", "\n") +
+        (0 until arity)
+          .map(i => s"?S rsa:${pred :: Nth(i)} ?X$i .")
+          .mkString("WHERE {\n", "\n", "\n}")
+    } else {
+      s"ASK { ?X a rsa:$pred }"
+    }
+  }
+
+  /** Reify a [[tech.oxfordsemantic.jrdfox.logic.datalog.Rule Rule]].
+    *
+    * This is needed because RDFox supports only predicates of arity 1
+    * or 2, but the filtering program uses predicates with higher arity.
+    *
+    * @note we can perform a reification of the atoms thanks to the
+    * built-in `SKOLEM` funtion of RDFox.
+    */
+  def reify(rule: Rule): Rule = {
+    val (bs, as) = rule.getHead.map(_.reified).unzip
+    val head: List[TupleTableAtom] = as.flatten
+    val bind: List[BodyFormula] = bs.flatten
+    val body: List[BodyFormula] = rule.getBody.map(reify).flatten
+    Rule.create(head, bind ::: body)
+  }
+
+  /** Reify a [[tech.oxfordsemantic.jrdfox.logic.datalog.BodyFormula BodyFormula]].
+    *
+    * This is needed because RDFox supports only predicates of arity 1
+    * or 2, but the filtering program uses predicates with higher arity.
+    *
+    * @note we can perform a reification of the atoms thanks to the
+    * built-in `SKOLEM` funtion of RDFox.
+    */
+  private def reify(formula: BodyFormula): List[BodyFormula] = {
+    formula match {
+      case atom: TupleTableAtom => atom.reified._2
+      case neg: Negation => {
+        val (bs, as) = neg.getNegatedAtoms
+          .map({
+            case a: TupleTableAtom => a.reified
+            case a                 => (None, List(a))
+          })
+          .unzip
+        val bind = bs.flatten.map(_.getBoundVariable)
+        val atoms = as.flatten
+        List(Negation.create(bind, atoms))
+      }
+      case other => List(other)
+    }
+  }
+
+  /** Close an open connection to RDFox.
+    *
+    * @param server server connection
+    * @param data data store connections
+    *
+    * @see [[uk.ac.ox.cs.rsacomb.util.RDFoxUtil.openConnection RDFoxUtil.openConnection]]
+    * for details on how to create a new connection with RDFox.
+    */
+  def closeConnection(
+      server: ServerConnection,
+      data: DataStoreConnection
+  ): Unit = {
+    data.close();
+    server.close();
+  }
+
+}
diff --git a/src/test/scala/uk/ac/ox/cs/rsacomb/CanonicalModelSpec.scala b/src/test/scala/uk/ac/ox/cs/rsacomb/CanonicalModelSpec.scala
index 376729c..3070ce3 100644
--- a/src/test/scala/uk/ac/ox/cs/rsacomb/CanonicalModelSpec.scala
+++ b/src/test/scala/uk/ac/ox/cs/rsacomb/CanonicalModelSpec.scala
@@ -15,7 +15,7 @@ import tech.oxfordsemantic.jrdfox.logic.expression.Variable
 import scala.collection.JavaConverters._
 
 import uk.ac.ox.cs.rsacomb.RSAOntology
-import uk.ac.ox.cs.rsacomb.util.{RDFoxHelpers, RSA}
+import uk.ac.ox.cs.rsacomb.util.{RDFoxUtil, RSA}
 
 object Ontology1_CanonicalModelSpec {
 
-- 
cgit v1.2.3