misc style tweaks

Author: ryan-williams

src/main/scala/net/virtualvoid/sbt/graph/DependencyGraphSettings.scala

@@ -16,18 +16,18 @@
 
 package net.virtualvoid.sbt.graph
 
-import scala.language.reflectiveCalls
-
-import sbt._
-import Keys._
-import sbt.complete.Parser
+import net.virtualvoid.sbt.graph.GraphTransformations.reverseGraphStartingAt
 import net.virtualvoid.sbt.graph.backend.{ IvyReport, SbtUpdateReport }
 import net.virtualvoid.sbt.graph.rendering.{ AsciiGraph, AsciiTree, DagreHTML }
 import net.virtualvoid.sbt.graph.util.IOUtil
-import internal.librarymanagement._
-import librarymanagement._
+import sbt.Keys._
+import sbt._
+import sbt.complete.Parser
 import sbt.dependencygraph.DependencyGraphSbtCompat
 import sbt.dependencygraph.DependencyGraphSbtCompat.Implicits._
+import sbt.internal.librarymanagement._
+
+import scala.language.reflectiveCalls
 
 object DependencyGraphSettings {
   import DependencyGraphKeys._
@@ -48,7 +48,17 @@ object DependencyGraphSettings {
     ivyReport := { Def.task { ivyReportFunction.value.apply(config.toString) } dependsOn (ignoreMissingUpdate) }.value,
     crossProjectId := sbt.CrossVersion(scalaVersion.value, scalaBinaryVersion.value)(projectID.value),
     moduleGraphSbt :=
-      ignoreMissingUpdate.value.configuration(configuration.value).map(report ⇒ SbtUpdateReport.fromConfigurationReport(report, crossProjectId.value)).getOrElse(ModuleGraph.empty),
+      ignoreMissingUpdate
+      .value
+      .configuration(configuration.value)
+      .map(
+        report ⇒
+          SbtUpdateReport.fromConfigurationReport(
+            report,
+            crossProjectId.value
+          )
+      )
+      .getOrElse(ModuleGraph.empty),
     moduleGraphIvyReport := IvyReport.fromReportFile(absoluteReportPath(ivyReport.value)),
     moduleGraph := {
       sbtVersion.value match {
@@ -92,8 +102,17 @@ object DependencyGraphSettings {
       """%s<BR/><B>%s</B><BR/>%s""".format(organisation, name, version)
     },
     whatDependsOn := {
-      val module = artifactIdParser.parsed
-      streams.value.log.info(AsciiTree(GraphTransformations.reverseGraphStartingAt(moduleGraph.value, module)))
+      streams
+        .value
+        .log
+        .info(
+          AsciiTree(
+            reverseGraphStartingAt(
+              moduleGraph.value,
+              artifactIdParser.parsed
+            )
+          )
+        )
     },
     licenseInfo := showLicenseInfo(moduleGraph.value, streams.value)) ++ AsciiGraph.asciiGraphSetttings)
 
@@ -105,7 +124,7 @@ object DependencyGraphSettings {
     (config: String) ⇒ {
       val org = projectID.organization
       val name = crossName(ivyModule)
-      file(s"${crossTarget}/resolution-cache/reports/$org-$name-$config.xml")
+      file(s"$crossTarget/resolution-cache/reports/$org-$name-$config.xml")
     }
   }
 
@@ -151,29 +170,57 @@ object DependencyGraphSettings {
       }.mkString("\n\n")
     streams.log.info(output)
   }
-
-  import Project._
   val shouldForceParser: State ⇒ Parser[Boolean] = { (state: State) ⇒
     import sbt.complete.DefaultParsers._
 
     (Space ~> token("--force")).?.map(_.isDefined)
   }
 
+  val filterRulesParser: Def.Initialize[State ⇒ Parser[Seq[FilterRule]]] =
+    resolvedScoped { ctx ⇒
+      (state: State) ⇒
+        import sbt.complete.DefaultParsers._
+        (Space ~> token(StringBasic, "filter")).*.map {
+          _.map(FilterRule(_))
+        }
+    }
+
   val artifactIdParser: Def.Initialize[State ⇒ Parser[ModuleId]] =
     resolvedScoped { ctx ⇒
       (state: State) ⇒
         val graph = loadFromContext(moduleGraphStore, ctx, state) getOrElse ModuleGraph(Nil, Nil)
 
         import sbt.complete.DefaultParsers._
-        graph.nodes.map(_.id).map {
-          case id @ ModuleId(org, name, version) ⇒
-            (Space ~ token(org) ~ token(Space ~ name) ~ token(Space ~ version)).map(_ ⇒ id)
-        }.reduceOption(_ | _).getOrElse {
-          (Space ~> token(StringBasic, "organization") ~ Space ~ token(StringBasic, "module") ~ Space ~ token(StringBasic, "version")).map {
-            case ((((org, _), mod), _), version) ⇒
-              ModuleId(org, mod, version)
+        graph
+          .nodes
+          .map(_.id)
+          .map {
+            case id @ ModuleId(org, name, version) ⇒
+              (
+                Space ~
+                token(org) ~
+                token(Space ~ name) ~
+                token(Space ~ version))
+                .map(_ ⇒ id)
+          }
+          .reduceOption(_ | _)
+          .getOrElse {
+            (
+              Space ~>
+              token(StringBasic, "organization") ~ Space ~
+              token(StringBasic, "module") ~ Space ~
+              token(StringBasic, "version"))
+              .map {
+                case (
+                  (
+                    ((org, _), mod),
+                    _
+                    ),
+                  version
+                  ) ⇒
+                  ModuleId(org, mod, version)
+              }
           }
-        }
     }
 
   // This is to support 0.13.8's InlineConfigurationWithExcludes while not forcing 0.13.8

src/main/scala/net/virtualvoid/sbt/graph/model.scala

@@ -73,5 +73,5 @@ object ModuleGraphProtocol extends ModuleGraphProtocolCompat {
   implicit def seqFormat[T: Format]: Format[Seq[T]] = wrap[Seq[T], List[T]](_.toList, _.toSeq)
   implicit val ModuleIdFormat: Format[ModuleId] = asProduct3(ModuleId)(ModuleId.unapply(_).get)
   implicit val ModuleFormat: Format[Module] = asProduct6(Module)(Module.unapply(_).get)
-  implicit val ModuleGraphFormat: Format[ModuleGraph] = asProduct2(ModuleGraph.apply _)(ModuleGraph.unapply(_).get)
+  implicit val ModuleGraphFormat: Format[ModuleGraph] = asProduct2(ModuleGraph.apply)(ModuleGraph.unapply(_).get)
 }

src/main/scala/net/virtualvoid/sbt/graph/rendering/AsciiTree.scala

@@ -17,23 +17,35 @@
 package net.virtualvoid.sbt.graph
 package rendering
 
-import util.AsciiTreeLayout
+import util.AsciiTreeLayout.toAscii
 import util.ConsoleUtils._
 
 object AsciiTree {
   def asciiTree(graph: ModuleGraph): String = {
     val deps = graph.dependencyMap
 
     // there should only be one root node (the project itself)
-    val roots = graph.roots
-    roots.map { root ⇒
-      AsciiTreeLayout.toAscii[Module](root, node ⇒ deps.getOrElse(node.id, Seq.empty[Module]), displayModule)
-    }.mkString("\n")
+    graph
+      .roots
+      .map {
+        root ⇒
+          toAscii[Module](
+            root,
+            node ⇒
+              deps.getOrElse(
+                node.id,
+                Seq.empty[Module]),
+            displayModule)
+      }
+      .mkString("\n")
   }
 
   def displayModule(module: Module): String =
-    red(module.id.idString +
-      module.extraInfo +
-      module.error.map(" (error: " + _ + ")").getOrElse("") +
-      module.evictedByVersion.map(_ formatted " (evicted by: %s)").getOrElse(""), module.hadError)
+    red(
+      module.id.idString +
+        module.extraInfo +
+        module.error.map(" (error: " + _ + ")").getOrElse("") +
+        module.evictedByVersion.map(_ formatted " (evicted by: %s)").getOrElse(""),
+      module.hadError
+    )
 }