Reformat with scalafmt 3.5.9

Executed command: scalafmt --non-interactive

Author: scala-steward

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

@@ -7,10 +7,9 @@ import alleycats.std.set._
 import cats.effect._
 import scala.util.Try
 
-
 case class Edge[Node, EdgeType](sub: Node, sup: Node, etype: EdgeType) {
 
- def show(showNode: Node => String, showEdge: EdgeType => String): String =
+  def show(showNode: Node => String, showEdge: EdgeType => String): String =
     s"${showNode(sub)}${showEdge(etype)}${showNode(sup)}"
 
 }
@@ -19,11 +18,13 @@ case class InheritanceJGraphT[Node, EdgeType](
     refGraph: Ref[IO, DirectedAcyclicGraph[Node, Edge[Node, EdgeType]]]
 ) extends Inheritance[Node, EdgeType] {
 
-  case class ErrorAddingNode(node: Node, e: Throwable) 
-   extends RuntimeException(s"Error adding node: $node. Err: ${e.getMessage()}")
+  case class ErrorAddingNode(node: Node, e: Throwable)
+      extends RuntimeException(s"Error adding node: $node. Err: ${e.getMessage()}")
 
-  case class ErrorAddingInheritance(node1: Node, node2: Node, etype: EdgeType, e: Throwable) 
-   extends RuntimeException(s"Error adding inheritance. Node1: $node1, Node2: $node2, etype: $etype, err: ${e.getMessage()}") 
+  case class ErrorAddingInheritance(node1: Node, node2: Node, etype: EdgeType, e: Throwable)
+      extends RuntimeException(
+        s"Error adding inheritance. Node1: $node1, Node2: $node2, etype: $etype, err: ${e.getMessage()}"
+      )
 
   override def clear: IO[Unit] = for {
     graph <- getGraph
@@ -39,25 +40,23 @@ case class InheritanceJGraphT[Node, EdgeType](
     graph <- getGraph
   } yield graph.vertexSet.asScala.toSet
 
-  override def addNode(node: Node): IO[Unit] = 
-    getGraph.flatMap(graph => {
-      Try(graph.addVertex(node)).fold(e => 
-        IO.raiseError(ErrorAddingNode(node, e)),
-        v => IO.pure(()) 
-      )
-    })
+  override def addNode(node: Node): IO[Unit] =
+    getGraph.flatMap { graph =>
+      Try(graph.addVertex(node))
+        .fold(e => IO.raiseError(ErrorAddingNode(node, e)), v => IO.pure(()))
+    }
 
   override def addInheritance(node1: Node, node2: Node, etype: EdgeType): IO[Unit] =
     getGraph.flatMap(graph =>
       Try {
-       graph.addVertex(node1)
-       graph.addVertex(node2)
-       graph.addEdge(node1, node2, Edge(node1, node2, etype))
+        graph.addVertex(node1)
+        graph.addVertex(node2)
+        graph.addEdge(node1, node2, Edge(node1, node2, etype))
       }.fold(
-        e => IO.raiseError(ErrorAddingInheritance(node1,node2,etype,e)),
+        e => IO.raiseError(ErrorAddingInheritance(node1, node2, etype, e)),
         v => IO.pure(())
       )
-      )
+    )
 
   override def descendants(node: Node): IO[Set[Node]] = for {
     graph <- getGraph

modules/rbe/src/main/scala/es/weso/graph/GraphMap.scala

@@ -3,8 +3,8 @@ package es.weso.graph
 /** Implementation of graph as a map
   */
 case class GraphMap[Edge, Node](
-  m: Map[Node, Seq[(Edge, Node)]]
-  ) extends Graph[Edge, Node] {
+    m: Map[Node, Seq[(Edge, Node)]]
+) extends Graph[Edge, Node] {
   def nodes = m.keys.toSeq
   def triples =
     m.map { case (x, out) => out.map { case (e, o) => (x, e, o) } }.flatten.toSeq

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

@@ -16,8 +16,7 @@ case class Schema[Edge, Node, Label, Err, Evidence](
 }
 
 object Schema {
-  def empty[Edge, Node, Label, Err, Evidence](): 
-     Schema[Edge, Node, Label, Err, Evidence] =
+  def empty[Edge, Node, Label, Err, Evidence](): Schema[Edge, Node, Label, Err, Evidence] =
     Schema(Map(), Seq())
 
 }

modules/rbe/src/main/scala/es/weso/rbe/deriv/DerivChecker.scala

@@ -7,7 +7,7 @@ import cats.implicits._
 
 case class DerivChecker[A: Show, Ordering](rbe: Rbe[A]) extends BagChecker[A] {
 
-  def check(bag: Bag[A], open: Boolean): Either[NonEmptyList[RbeError], Bag[A]] = {
+  def check(bag: Bag[A], open: Boolean): Either[NonEmptyList[RbeError], Bag[A]] =
     rbe.derivBag(bag, open, rbe.symbols) match {
       case f: Fail => NonEmptyList.one(f.error).asLeft
       case d =>
@@ -16,5 +16,4 @@ case class DerivChecker[A: Show, Ordering](rbe: Rbe[A]) extends BagChecker[A] {
           case Left(m)  => NonEmptyList.one(NonNullableError(d, rbe, bag, open, m)).asLeft
         }
     }
-  }
 }

modules/rbe/src/main/scala/es/weso/rbe/interval/IntervalChecker.scala

@@ -39,7 +39,7 @@ case class IntervalChecker[A: Show](rbe: Rbe[A]) extends BagChecker[A] {
               // In case of fail, check using derivatives to obtain better error messages
               // TODO: Could it be optimized knowing that it will fail?
               derivChecker.check(bag, open)
-            // NonEmptyList.one(IntervalError(interval,rbe,bag,open)).asLeft
+          // NonEmptyList.one(IntervalError(interval,rbe,bag,open)).asLeft
         } yield v
     }
 

modules/shapepath/src/main/scala/es/weso/shapepath/ShapePath.scala

@@ -217,7 +217,7 @@ object ShapePath {
             case _: ShapeNot =>
               warning(s"ShapeNot: evaluating index ${index.show} returns no item") >>
                 ok(current)
-            case sd: ShapeDecl => 
+            case sd: ShapeDecl =>
               cmb(current, ShapeExprItem(sd.shapeExpr))
             case s: Shape =>
               index match {

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

@@ -81,11 +81,14 @@ object ExtendsConverter {
           case _        => ok(ShapeOr(id = Some(lbl), shapeExprs = maybeR.map(_.rmId), None, None))
         }
       } yield r
-    case ShapeDecl(lbl, se, false) => cnvDescendants(schema)(se).flatMap(ds => ds match {
-      case Nil =>  err[ShapeExpr](s"No descendants for ${schema.qualify(lbl)}?")
-      case s :: Nil => ok(s.addId(lbl))
-      case _ => ok(ShapeOr(id = Some(lbl), shapeExprs = ds.map(_.rmId), None, None))
-    }) 
+    case ShapeDecl(lbl, se, false) =>
+      cnvDescendants(schema)(se).flatMap(ds =>
+        ds match {
+          case Nil      => err[ShapeExpr](s"No descendants for ${schema.qualify(lbl)}?")
+          case s :: Nil => ok(s.addId(lbl))
+          case _        => ok(ShapeOr(id = Some(lbl), shapeExprs = ds.map(_.rmId), None, None))
+        }
+      )
   }
 
   private def mkDisj(schema: ResolvedSchema)(se: ShapeExpr): Cnv[ShapeExpr] = for {

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

@@ -53,13 +53,13 @@ object InheritanceGraph {
   ): IO[Unit] =
     se match {
       case s: Shape => addExtendsRestricts(g, sub, s)
-/*      case s: ShapeAnd =>
-        s.shapeExprs.foldM(()){ 
-          case (_, se) => addShapeExpr(g, sub, se, verbose) 
+      /*      case s: ShapeAnd =>
+        s.shapeExprs.foldM(()){
+          case (_, se) => addShapeExpr(g, sub, se, verbose)
         } */
       case sd: ShapeDecl => addShapeExpr(g, sub, sd.shapeExpr, verbose)
-      case sr: ShapeRef => g.addInheritance(sub, sr.reference, References)
-      case _            => ().pure[IO]
+      case sr: ShapeRef  => g.addInheritance(sub, sr.reference, References)
+      case _             => ().pure[IO]
     }
 
   private def addPair(g: Inheritance[ShapeLabel, ShapesRelation], verboseLevel: VerboseLevel)(

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

@@ -18,5 +18,6 @@ case class ResolvedShapeExpr(
 
 object ResolvedShapeExpr {
   def apply(se: ShapeExpr): ResolvedShapeExpr = ResolvedShapeExpr(se, None, Set(), List())
-  def apply(se: ShapeExpr, iri: IRI): ResolvedShapeExpr = ResolvedShapeExpr(se, Some(iri), Set(), List())
+  def apply(se: ShapeExpr, iri: IRI): ResolvedShapeExpr =
+    ResolvedShapeExpr(se, Some(iri), Set(), List())
 }

modules/shex/src/main/scala/es/weso/shex/compact/CompactShow.scala

@@ -144,7 +144,10 @@ object CompactShow {
           semActsDoc(pm)
         )
       case ShapeDecl(id, se, b) =>
-        (if (b) str("abstract") else str("")):: space :: idDoc(Some(id), pm) :: space :: shapeExprDoc(pm)(se)
+        (if (b) str("abstract") else str("")) :: space :: idDoc(
+          Some(id),
+          pm
+        ) :: space :: shapeExprDoc(pm)(se)
       case other => str(s"ERROR: Unknown type of ShapeExpr: ${other}")
     }