filter dependency-tree with inclusion/exclusion rules

Author: ryan-williams

README.md

@@ -21,7 +21,7 @@ the notes of version [0.8.2](https://github.com/jrudolph/sbt-dependency-graph/tr
 
 ## Main Tasks
 
- * `dependencyTree`: Shows an ASCII tree representation of the project's dependencies
+ * `dependencyTree`: Shows an ASCII tree representation of the project's dependencies (see [below](#dependencyTree-filtering) for examples filtering the output)
  * `dependencyBrowseGraph`: Opens a browser window with a visualization of the dependency graph (courtesy of graphlib-dot + dagre-d3).
  * `dependencyList`: Shows a flat list of all transitive dependencies on the sbt console (sorted by organization and name)
  * `whatDependsOn <organization> <module> <revision>`: Find out what depends on an artifact. Shows a reverse dependency
@@ -40,6 +40,43 @@ All tasks can be scoped to a configuration to get the report for a specific conf
 for example, prints the dependencies in the `test` configuration. If you don't specify any configuration, `compile` is
 assumed as usual.
 
+### `dependencyTree` filtering
+The `dependencyTree` task supports filtering with inclusion/exclusion rules:
+
+- exclusion rules are prefixed by `-`
+- inclusion rules are the default (or can be prefixed by `+`)
+
+Dependencies are "preserved" iff:
+- they match at least one inclusion rule (or no inclusion rules are provided), and
+- they match no exclusion rules (including when none are provided)
+
+They are then displayed if they are preserved *or at least one of their transitive dependencies is preserved*.
+
+This mimics the behavior of [Maven dependency:tree](https://maven.apache.org/plugins/maven-dependency-plugin/tree-mojo.html)'s `includes` and `excludes` parameters.
+
+#### Examples
+
+Inclusions/Exclusions can be partial-matched against any part of a dependency's Maven coordinate:
+
+```
+dependencyTree -foo          // exclude deps that contain "foo" in the group, name, or version
+dependencyTree foo           // include deps that contain "foo" in the group, name, or version
+```
+
+Or they can be fully-matched against specific parts of the coordinate:
+
+```
+dependencyTree -:foo*        // exclude deps whose name starts with "foo"
+dependencyTree -*foo*::*bar  // exclude deps whose group contains "foo" and version ends with "bar"
+```
+
+Inclusions and exclusions can be combined and repeated:
+```
+dependencyTree foo bar -baz  // include only deps that contain "foo" or "bar" and not "baz"
+```
+
+In all cases, the full paths to dependencies that match the query are displayed (which can mean that dependencies are displayed even though they would have been excluded in their own right, because they form part of a chain to a dependency that was not excluded). 
+
 ## Configuration settings
 
  * `filterScalaLibrary`: Defines if the scala library should be excluded from the output of the dependency-* functions.

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

@@ -50,9 +50,9 @@ trait DependencyGraphKeys {
     "Returns a string containing the ascii representation of the dependency graph for a project")
   val dependencyGraph = InputKey[Unit]("dependency-graph",
     "Prints the ascii graph to the console")
-  val asciiTree = TaskKey[String]("dependency-tree-string",
+  val asciiTree = InputKey[String]("dependency-tree-string",
     "Returns a string containing an ascii tree representation of the dependency graph for a project")
-  val dependencyTree = TaskKey[Unit]("dependency-tree",
+  val dependencyTree = InputKey[Unit]("dependency-tree",
     "Prints an ascii tree of all the dependencies to the console")
   val dependencyList = TaskKey[Unit]("dependency-list",
     "Prints a list of all dependencies to the console")

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

@@ -18,7 +18,7 @@ package net.virtualvoid.sbt.graph
 
 import net.virtualvoid.sbt.graph.GraphTransformations.reverseGraphStartingAt
 import net.virtualvoid.sbt.graph.backend.{ IvyReport, SbtUpdateReport }
-import net.virtualvoid.sbt.graph.model.{ ModuleGraph, ModuleId }
+import net.virtualvoid.sbt.graph.model.{ FilterRule, ModuleGraph, ModuleId }
 import net.virtualvoid.sbt.graph.rendering.{ AsciiGraph, AsciiTree, DagreHTML }
 import net.virtualvoid.sbt.graph.util.IOUtil
 import sbt.Keys._
@@ -76,8 +76,11 @@ object DependencyGraphSettings {
       else moduleGraph
     },
     moduleGraphStore := (moduleGraph storeAs moduleGraphStore triggeredBy moduleGraph).value,
-    asciiTree := AsciiTree(moduleGraph.value),
-    dependencyTree := print(asciiTree).value,
+    asciiTree := AsciiTree(
+      moduleGraph.value,
+      filterRulesParser.parsed: _*
+    ),
+    dependencyTree := streams.value.log.info(asciiTree.evaluated),
     dependencyGraphMLFile := { target.value / "dependencies-%s.graphml".format(config.toString) },
     dependencyGraphML := dependencyGraphMLTask.value,
     dependencyDotFile := { target.value / "dependencies-%s.dot".format(config.toString) },

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

@@ -0,0 +1,131 @@
+package net.virtualvoid.sbt.graph.model
+
+import scala.language.implicitConversions
+import scala.util.matching.Regex
+
+/**
+ * Interface for [[Include]] and [[Exclude]] rules for filtering the output of the
+ * [[net.virtualvoid.sbt.graph.DependencyGraphKeys.dependencyTree dependencyTree]] task
+ */
+sealed trait FilterRule {
+  def pattern: ModuleIdPattern
+  def apply(node: ModuleId): Boolean = pattern(node)
+}
+
+object FilterRule {
+  implicit def apply(s: String): FilterRule =
+    if (s.startsWith("-"))
+      Exclude(s.substring(1))
+    else if (s.startsWith("+"))
+      Include(s.substring(1))
+    else
+      Include(s)
+}
+
+/**
+ * If a [[ModuleId]] matches [[pattern]], include it in results
+ */
+case class Include(pattern: ModuleIdPattern) extends FilterRule
+object Include {
+  def apply(pattern: String): Include = Include(ModuleIdPattern(pattern))
+}
+
+/**
+ * If a [[ModuleId]] matches [[pattern]], exclude it from results
+ */
+case class Exclude(pattern: ModuleIdPattern) extends FilterRule
+object Exclude {
+  def apply(pattern: String): Exclude = Exclude(ModuleIdPattern(pattern))
+}
+
+/**
+ * Interface for patterns that can be matched against [[ModuleId]]s, either based on patterns that fully match one or
+ * more of the (group, artifact, version) segments ([[PerSegmentPatterns]]), or that partially match any of them
+ * ([[AnySegmentPattern]])
+ */
+sealed trait ModuleIdPattern {
+  /**
+   * Does this [[ModuleId]] match this pattern?
+   */
+  def apply(moduleId: ModuleId): Boolean
+}
+
+object ModuleIdPattern {
+
+  /**
+   * Build a [[Regex]] from a [[String]] specifying a module-id pattern:
+   *
+   * - escape "dot" (`.`) characters
+   * - replace "glob"/stars with `.*`
+   *
+   * This is more ergonomic than PCRE for Maven coordinates, since literal dots are used frequently, and other
+   * regex-special-chars (e.g. `[`/`]`, `{`/`}`, `+`) are not.
+   */
+  def regex(s: String): Regex =
+    if (s.isEmpty)
+      any
+    else
+      s
+        .replace(".", "\\.")
+        .replace("*", ".*")
+        .r
+
+  private val any = ".*".r
+
+  /**
+   * Generate a [[ModuleIdPattern]] from a loose Maven-coordinate-style specification:
+   *
+   * - "foo": coordinates whose group, artifact, or version contains "foo"
+   * - "foo:": coordinates whose group is exactly "foo"
+   * - "foo*": coordinates whose group begins with "foo"
+   * - "*foo": coordinates whose group ends with "foo"
+   * - "*foo*": coordinates whose group contains "foo"
+   * - ":foo", ":foo:": coordinates whose name is "foo"
+   * - ":foo*": coordinates whose name begins with "foo"
+   * - "::*foo": coordinates whose version ends with "foo"
+   * - "foo*::*bar*": coordinates whose group begins with "foo" and version contains "bar"
+   */
+  def apply(s: String): ModuleIdPattern =
+    s.split(":", -1) match {
+      // encodes a partial-match against any segment
+      case Array(_)                    ⇒ AnySegmentPattern(regex(s))
+
+      // encode full-matches against all segments with non-empty patterns
+      case Array(group, name)          ⇒ PerSegmentPatterns(regex(group), regex(name), any)
+      case Array(group, name, version) ⇒ PerSegmentPatterns(regex(group), regex(name), regex(version))
+    }
+}
+
+/**
+ * Match [[ModuleId]]s whose group, name, and version each fully-match the corresponding provided [[Regex]]
+ */
+case class PerSegmentPatterns(group: Regex,
+                              name: Regex,
+                              version: Regex)
+    extends ModuleIdPattern {
+  def apply(moduleId: ModuleId): Boolean =
+    moduleId match {
+      case ModuleId(group(), name(), version()) ⇒
+        true
+      case _ ⇒
+        false
+    }
+}
+
+/**
+ * Match [[ModuleId]]s where at least one of their {group, name, version} partially-match [[regex]]
+ */
+case class AnySegmentPattern(regex: Regex)
+    extends ModuleIdPattern {
+  def apply(m: ModuleId): Boolean =
+    Seq(
+      m.organisation,
+      m.name,
+      m.version
+    )
+      .exists(
+        regex
+          .findFirstIn(_)
+          .isDefined
+      )
+}

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

@@ -17,13 +17,13 @@
 package net.virtualvoid.sbt.graph
 package rendering
 
-import net.virtualvoid.sbt.graph.model.{ Module, ModuleGraph }
+import net.virtualvoid.sbt.graph.model.{ FilterRule, Module, ModuleGraph }
 import util.AsciiTreeLayout.toAscii
 import util.ConsoleUtils._
 
 object AsciiTree {
-  def asciiTree(graph: ModuleGraph): String = {
-    val deps = graph.dependencyMap
+  def apply(graph: ModuleGraph, filterRules: FilterRule*): String = {
+    val deps = graph.filter(filterRules: _*)
 
     // there should only be one root node (the project itself)
     graph

src/sbt-test/sbt-dependency-graph/ignoreScalaLibrary/build.sbt

@@ -5,14 +5,13 @@ libraryDependencies ++= Seq(
   "ch.qos.logback" % "logback-classic" % "1.0.7"
 )
 
-TaskKey[Unit]("check") := {
+InputKey[Unit]("check") := {
   val report = (ivyReport in Test).value
-  val graph = (asciiTree in Test).value
+  val graph = (asciiTree in Test).evaluated
   def sanitize(str: String): String = str.split('\n').drop(1).map(_.trim).mkString("\n")
   val expectedGraph =
     """default:default-e95e05_2.9.2:0.1-SNAPSHOT [S]
       |  +-ch.qos.logback:logback-classic:1.0.7
-      |  | +-ch.qos.logback:logback-core:1.0.7
       |  | +-org.slf4j:slf4j-api:1.6.6 (evicted by: 1.7.2)
       |  | +-org.slf4j:slf4j-api:1.7.2
       |  |

src/sbt-test/sbt-dependency-graph/ignoreScalaLibrary/test

@@ -1 +1 @@
-> check
+> check -qos

src/sbt-test/sbt-dependency-graph/intervalRangedVersions/build.sbt

@@ -6,9 +6,9 @@ libraryDependencies ++= Seq(
   "com.codahale" % "jerkson_2.9.1" % "0.5.0"
 )
 
-TaskKey[Unit]("check") := {
+InputKey[Unit]("check") := {
   val report = (ivyReport in Test).value
-  val graph = (asciiTree in Test).value
+  val graph = (asciiTree in Test).evaluated
 
   def sanitize(str: String): String = str.split('\n').drop(1).map(_.trim).mkString("\n")
   val expectedGraph =

src/sbt-test/sbt-dependency-graph/showMissingUpdates/build.sbt

@@ -3,9 +3,9 @@ scalaVersion := "2.9.2"
 libraryDependencies +=
   "at.blub" % "blib" % "1.2.3" % "test"
 
-TaskKey[Unit]("check") := {
+InputKey[Unit]("check") := {
   val report = (ivyReport in Test).value
-  val graph = (asciiTree in Test).value
+  val graph = (asciiTree in Test).evaluated
 
   def sanitize(str: String): String = str.split('\n').drop(1).mkString("\n")
   val expectedGraph =