Seems to work

Author: labra

CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+
+## v0.2.34 - 2025-04-25
+
+Added option to show dependency graph and repaired issue #623

build.sbt

@@ -2,9 +2,9 @@ lazy val scala212 = "2.12.20"
 lazy val scala213 = "2.13.15"
 lazy val scala3 = "3.6.3"
 lazy val supportedScalaVersions = List(
+  scala212,
   scala213,
-  scala3,
-  scala212
+  scala3
 )
 
 val Java11 = JavaSpec.temurin("11")

examples/non_stratified.shex

@@ -0,0 +1,3 @@
+prefix :       <http://example.org/> 
+
+:S { :p NOT @:S }

examples/positive_recursion.shex

@@ -0,0 +1,4 @@
+prefix :       <http://example.org/> 
+
+# Positive recursion 
+:S  { :p @:S +; :p .* } OR [ :d ]

examples/separation.shex

@@ -1,8 +1,5 @@
 prefix :       <http://example.org/> 
 
 # Separation test 
-:S {
-    :p @:S +
-}
-
+:S { :p @:S + }
 :S1 NOT @:S 

examples/separation1.shex

@@ -0,0 +1,4 @@
+prefix :       <http://example.org/> 
+
+# Separation test 1
+:S { :p @:S + }

examples/separation2.shex

@@ -0,0 +1,4 @@
+prefix :       <http://example.org/> 
+
+# Separation test 1
+:S { :p @:S + }

examples/separation4.shex

@@ -0,0 +1,5 @@
+prefix :       <http://example.org/> 
+
+# Separation test 
+:S { :p @:S + }
+:S1 NOT @:S 

modules/depGraphs/src/main/scala/es/weso/depgraphs/DepGraph.scala

@@ -48,10 +48,10 @@ trait DepGraph[Node] {
 
   private def haveNegativeLink(node1: Node, node2: Node): Boolean =
     edgeBetween(node1, node2) match {
-      case Some(Neg)  => true
-      case Some(Pos)  => false
-      case Some(Both) => true
-      case None       => false
+      case Some(Neg) => true
+      case Some(Pos) => false
+      // case Some(Both) => true
+      case None => false
     }
 
   def showEdges(showNode: Node => String = x => x.toString): String

modules/depGraphs/src/main/scala/es/weso/depgraphs/DepGraphJGraphT.scala

@@ -46,7 +46,7 @@ case class DepGraphJGraphT[Node]() extends DepGraph[Node] with LazyLogging {
     // if (!graph.containsVertex(node))
     graph.addVertex(node)
 
-  private def addEdge(node1: Node, node2: Node, edge: Edge): DepGraph[Node] = {
+  private def addEdgeInternal(node1: Node, node2: Node, edge: Edge): DepGraph[Node] = {
     checkVertex(node1)
     checkVertex(node2)
     graph.addEdge(node1, node2, edge)
@@ -61,14 +61,19 @@ case class DepGraphJGraphT[Node]() extends DepGraph[Node] with LazyLogging {
     checkVertex(node2)
     this.edgeBetween(node1, node2) match {
       case Some(pn) =>
+        // println(s"Edge between $node1 and $node2 already exists with posNeg $pn")
         removeEdge(node1, node2)
-        addEdge(node1, node2, Edge(node1, pn.combine(posNeg), node2))
-      case None => addEdge(node1, node2, Edge(node1, posNeg, node2))
+        val newPosNeg = pn.combine(posNeg)
+        val result = addEdgeInternal(node1, node2, Edge(node1, newPosNeg, node2))
+        // println(s"New edge added $node1 and $node2 posNeg $newPosNeg")
+        result
+      case None => addEdgeInternal(node1, node2, Edge(node1, posNeg, node2))
     }
   }
 
   override def edgeBetween(node1: Node, node2: Node): Option[PosNeg] = {
-    val outEdges = graph.edgesOf(node1).asScala.toSet
+    val outEdges: Set[Edge] = graph.outgoingEdgesOf(node1).asScala.toSet
+    // println(s"outEdges($node1)=$outEdges")
     outEdges.collect { case e: Edge if e.target == node2 => e.posNeg }.headOption
   }
 
@@ -89,7 +94,7 @@ case class DepGraphJGraphT[Node]() extends DepGraph[Node] with LazyLogging {
     }
 
   private def containsNegEdge(g: Graph[Node, Edge]): Boolean =
-    g.edgeSet.asScala.exists(e => e.posNeg == Neg || e.posNeg == Both)
+    g.edgeSet.asScala.exists(e => e.posNeg == Neg) // || e.posNeg == Both)
 
   override def negCycles: Set[Set[(Node, Node)]] = {
     val scAlg: StrongConnectivityAlgorithm[Node, Edge] =
@@ -112,9 +117,9 @@ case class DepGraphJGraphT[Node]() extends DepGraph[Node] with LazyLogging {
 
   def showPosNeg(pn: PosNeg): String =
     pn match {
-      case Pos  => "-(+)->"
-      case Neg  => "-(-)->"
-      case Both => "-(-/+)->"
+      case Pos => "-(+)->"
+      case Neg => "-(-)->"
+      // case Both => "-(-/+)->"
     }
 
   def showEdges(showNode: Node => String): String = {

modules/depGraphs/src/main/scala/es/weso/depgraphs/PosNeg.scala

@@ -2,27 +2,29 @@ package es.weso.depgraphs
 
 sealed trait PosNeg {
   def change: PosNeg = this match {
-    case Neg  => Pos
-    case Pos  => Neg
-    case Both => Both
+    case Neg => Pos
+    case Pos => Neg
+    // case Both => Both
   }
   def combine(other: PosNeg): PosNeg
 }
 
 case object Pos extends PosNeg {
   override def combine(other: PosNeg): PosNeg = other match {
-    case Pos  => Pos
-    case Neg  => Both
-    case Both => Both
+    case Pos => Pos
+    case Neg => Neg
+    // case Neg => Both
+    // case Both => Both
   }
 }
 case object Neg extends PosNeg {
   override def combine(other: PosNeg): PosNeg = other match {
-    case Pos  => Both
-    case Neg  => Neg
-    case Both => Both
+    case Pos => Neg // Both
+    case Neg => Neg
+    // case Both => Both
   }
 }
-case object Both extends PosNeg {
+
+/*case object Both extends PosNeg {
   override def combine(other: PosNeg): PosNeg = Both
-}
+}*/

modules/shex/src/main/scala/es/weso/shex/Dependencies.scala

@@ -22,13 +22,12 @@ object Dependencies {
     *  If the set is empy, there are no negated cycles.
     */
   def negCycles(schema: Schema): ES[Set[Set[(ShapeLabel, ShapeLabel)]]] =
-    depGraph(schema).map(_.negCycles)
+    schema.depGraph.map(_.negCycles)
 
   def oddNegCycles(schema: Schema): ES[Set[Set[(ShapeLabel, ShapeLabel)]]] =
     // depGraph(schema).map(_.oddNegCycles)
     for {
-      dg <- depGraph(schema)
-      _ <- { println(s"Dependency graph: $dg"); Right(()) }
+      dg <- schema.depGraph
       negCycles = dg.negCycles.filter(nc => dg.countNegLinks(nc) % 2 == 1)
     } yield negCycles
 
@@ -43,15 +42,19 @@ object Dependencies {
       case None         => emptyGraph
       case Some(shapes) => shapes.foldRight(emptyGraph)(addDependency(schema))
     }
-    println(s"Dependency graph: $r")
+    /*r match {
+      case Left(s) => println(s"Error calculating dependency graph: $s")
+      case Right(g) =>
+        println(s"Dependency graph generated:\n${g.showEdges(_.toString)}\n---")
+    }*/
     r
   }
 
   def addDependencies(graph: DepGraph[ShapeLabel], deps: Deps): DepGraph[ShapeLabel] =
     deps.foldRight(graph)(combine)
 
   def combine(d: Dep, g: DepGraph[ShapeLabel]): DepGraph[ShapeLabel] =
-//    println(s"Adding edge $d to graph: $g")
+    // println(s"Adding edge $d to graph: $g")
     g.addEdge(d._1, d._2, d._3)
 
   def addDependency(
@@ -61,6 +64,7 @@ object Dependencies {
       g <- graph
       label <- getLabel(se)
       deps <- dependencies(schema, se, label, Pos)
+      // _ <- { println(s"dependencies: ${deps}"); Right(()) }
     } yield addDependencies(g, deps)
 
   def getLabel(se: ShapeExpr): ES[ShapeLabel] =
@@ -71,10 +75,8 @@ object Dependencies {
       shape: ShapeExpr,
       source: ShapeLabel,
       posNeg: PosNeg
-  ): ES[Deps] = {
-    println(
-      s"Calculating dependencies of shape $shape with source label $source and posNeg $posNeg"
-    )
+  ): ES[Deps] =
+    // println(s"Calculating dependencies of $source with shapeExpr $shape, posNeg $posNeg")
     shape match {
       case s: ShapeAnd =>
         s.shapeExprs.map(dependencies(schema, _, source, posNeg)).sequence[ES, Deps].map(_.flatten)
@@ -83,7 +85,7 @@ object Dependencies {
         s.shapeExprs.map(dependencies(schema, _, source, posNeg)).sequence[ES, Deps].map(_.flatten)
 
       case s: ShapeNot =>
-        dependencies(schema, s.shapeExpr, source, Neg)
+        dependencies(schema, s.shapeExpr, source, posNeg.change)
 
       case _: NodeConstraint => noDeps
 
@@ -109,15 +111,13 @@ object Dependencies {
       case _: ShapeExternal => noDeps
       case sd: ShapeDecl    => dependencies(schema, sd.shapeExpr, source, posNeg)
     }
-  }
 
   def dependenciesTripleExpr(
       schema: Schema,
       source: ShapeLabel,
       tripleExpr: TripleExpr,
       posNeg: PosNeg
   ): ES[Deps] =
-    // println(s"Calculating dependencies of tripleExpr $tripleExpr with source label $source and posNeg $posNeg")
     tripleExpr match {
       case t: EachOf =>
         // TODO: Take into account max cardinality = 0 as a negative dependency?
@@ -143,7 +143,7 @@ object Dependencies {
           case Some(ve) =>
             if (tc.max == IntMax(0)) {
               // TODO: Should it be negative dependency?
-              dependencies(schema, ve, source, posNeg.change)
+              dependencies(schema, ve, source, posNeg)
             } else {
               dependencies(schema, ve, source, posNeg)
             }

modules/shex/src/main/scala/es/weso/shex/ResolvedSchema.scala

@@ -22,6 +22,7 @@ case class ResolvedSchema(
     resolvedMapShapeExprs: Map[ShapeLabel, ResolvedShapeExpr],
     resolvedMapTripleExprs: Map[ShapeLabel, ResolvedTripleExpr],
     inheritanceGraph: Inheritance[ShapeLabel, ShapesRelation],
+    // depGraph: DepGraph[ShapeLabel],
     labelLocationMap: Option[Map[ShapeLabel, Location]]
 ) extends AbstractSchema {
 

modules/shex/src/main/scala/es/weso/shex/Schema.scala

@@ -101,13 +101,13 @@ case class Schema(
   def addTripleExprMap(te: Map[ShapeLabel, TripleExpr]): Schema =
     this.copy(optTripleExprMap = Some(te))
 
-  def oddNegCycles: Either[String, Set[Set[(ShapeLabel, ShapeLabel)]]] =
+  lazy val oddNegCycles: Either[String, Set[Set[(ShapeLabel, ShapeLabel)]]] =
     Dependencies.oddNegCycles(this)
 
-  def negCycles: Either[String, Set[Set[(ShapeLabel, ShapeLabel)]]] =
+  lazy val negCycles: Either[String, Set[Set[(ShapeLabel, ShapeLabel)]]] =
     Dependencies.negCycles(this)
 
-  def depGraph: Either[String, DepGraph[ShapeLabel]] =
+  lazy val depGraph: Either[String, DepGraph[ShapeLabel]] =
     Dependencies.depGraph(this)
 
   def showCycles(str: Either[String, Set[Set[(ShapeLabel, ShapeLabel)]]]): String = str match {
@@ -130,16 +130,15 @@ case class Schema(
     _ <- shapesMap.keySet.toList.map(lbl => checkShapeLabel(lbl)).sequence
   } yield (())
 
-  private lazy val checkOddNegCycles: Either[String, Unit] = {
-    println(s"OddNegCycles: $oddNegCycles")
+  private lazy val checkOddNegCycles: Either[String, Unit] =
+    // println(s"OddNegCycles: $oddNegCycles")
     oddNegCycles match {
       case Left(e) => Left(e)
       case Right(cs) =>
         if (cs.isEmpty) Right(())
         else
           Left(s"Negative cycles: ${showCycles(oddNegCycles)}")
     }
-  }
 
   lazy val wellFormed: Either[String, Unit] = for {
     _ <- checkOddNegCycles

src/main/scala/es/weso/shexs/SchemaCommand.scala

@@ -54,6 +54,7 @@ object ShowMethod {
 case class SchemaCommand(
     schemaSpec: SchemaSpec,
     showInheritance: Boolean,
+    showDependencyGraph: Boolean,
     showMethod: ShowMethod,
     showShape: Option[ShapeLabel],
     verbose: VerboseLevel
@@ -66,6 +67,9 @@ case class SchemaCommand(
     _ <-
       if (showInheritance) runShowInheritance(resolved)
       else IO.pure(())
+    _ <-
+      if (showDependencyGraph) showDepGraph(resolved)
+      else IO.pure(())
     _ <- showShape match {
       case None     => IO.pure(())
       case Some(sl) => runShowShapeLabel(sl, resolved, showMethod)
@@ -89,6 +93,16 @@ case class SchemaCommand(
     )
   }
 
+  private def showDepGraph(schema: ResolvedSchema): IO[Unit] = {
+    val eitherDepGraph = schema.source.depGraph
+    eitherDepGraph match {
+      case Left(err) =>
+        IO.println(s"Error obtaining dependency graph: $err")
+      case Right(depGraph) =>
+        IO.println(s"Dependency graph:\n${depGraph.showEdges(lbl => schema.qualify(lbl.toRDFNode))}")
+    }
+  }
+
   private def runShowInheritance(schema: ResolvedSchema): IO[Unit] = for {
     inheritanceStr <-
       schema.inheritanceGraph.show(lbl => schema.qualify(lbl.toRDFNode), r => s" -${r.name}-> ")
@@ -130,7 +144,9 @@ object SchemaCommand {
 
   val showInheritance: Opts[Boolean] =
     Opts.flag("show-inheritance", short = "i", help = "show inheritance graph").orFalse
-//  val showMethod: Opts[ShowMethod] = Opts.option[String]("show-qualified", short = "q", help = "show shapes qualified by prefix declarations").orFalse
+
+  val showDependencyGraph: Opts[Boolean] =
+    Opts.flag("show-dependency-graph", short = "d", help = "show dependency graph").orFalse
 
   val showShape: Opts[Option[ShapeLabel]] =
     UriOpt.uri("shape", help = "Show shape").map(uri => IRILabel(IRI(uri))).orNone
@@ -140,6 +156,7 @@ object SchemaCommand {
       (
         SchemaSpec.schemaSpec,
         showInheritance,
+        showDependencyGraph,
         ShowMethod.showMethodOpt,
         showShape,
         VerboseLevelOpt.verboseLevel

version.sbt

@@ -1 +1 @@
-ThisBuild / version := "0.2.33"
+ThisBuild / version := "0.2.34"