From 65dc88adc6225e28c39463dc7f894356d4fa43b7 Mon Sep 17 00:00:00 2001
From: Antonio Cunei <antonio.cunei@typesafe.com>
Date: Wed, 20 May 2015 03:26:30 +0200
Subject: [PATCH] Do not emit in the pom dependencies that are only sources or
 docs

The pom generation code tries its best to map Ivy's configurations
to Maven scopes; however, sources and javadoc artifacts cannot be
properly mapped and they currently are emitted as dependencies in
the default scope (compile). That may lead to the source/doc jars
being erroneously processed like regular jars by automated tools.

Arguably, the source/docs jars should not be included in the pom
file as dependencies at all. This commit filters out the
dependencies that only appear in the sources and/or javadoc Ivy
configurations, thereby preventing them from appearing in the
final pom file.
---
 ivy/src/main/scala/sbt/MakePom.scala | 29 ++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/ivy/src/main/scala/sbt/MakePom.scala b/ivy/src/main/scala/sbt/MakePom.scala
index d0e1a2741..16bd6002a 100644
--- a/ivy/src/main/scala/sbt/MakePom.scala
+++ b/ivy/src/main/scala/sbt/MakePom.scala
@@ -233,28 +233,33 @@ class MakePom(val log: Logger) {
       val artifacts = dependency.getAllDependencyArtifacts
       val includeArtifacts = artifacts.filter(d => includeTypes(d.getType))
       if (artifacts.isEmpty) {
-        val (scope, optional) = getScopeAndOptional(dependency.getModuleConfigurations)
-        makeDependencyElem(dependency, scope, optional, None, None)
+        val configs = dependency.getModuleConfigurations
+        if (configs.filterNot(Set("sources","docs")).nonEmpty) {
+          val (scope, optional) = getScopeAndOptional(dependency.getModuleConfigurations)
+          makeDependencyElem(dependency, scope, optional, None, None)
+        } else NodeSeq.Empty
       } else if (includeArtifacts.isEmpty)
         NodeSeq.Empty
       else
-        NodeSeq.fromSeq(artifacts.map(a => makeDependencyElem(dependency, a)))
+        NodeSeq.fromSeq(artifacts.flatMap(a => makeDependencyElem(dependency, a)))
     }
 
-  def makeDependencyElem(dependency: DependencyDescriptor, artifact: DependencyArtifactDescriptor): Elem =
+  def makeDependencyElem(dependency: DependencyDescriptor, artifact: DependencyArtifactDescriptor): Option[Elem] =
     {
       val configs = artifact.getConfigurations.toList match {
         case Nil | "*" :: Nil => dependency.getModuleConfigurations
         case x                => x.toArray
       }
-      val (scope, optional) = getScopeAndOptional(configs)
-      val classifier = artifactClassifier(artifact)
-      val baseType = artifactType(artifact)
-      val tpe = (classifier, baseType) match {
-        case (Some(c), Some(tpe)) if Artifact.classifierType(c) == tpe => None
-        case _ => baseType
-      }
-      makeDependencyElem(dependency, scope, optional, classifier, tpe)
+      if (configs.filterNot(Set("sources","docs")).nonEmpty) {
+        val (scope, optional) = getScopeAndOptional(configs)
+        val classifier = artifactClassifier(artifact)
+        val baseType = artifactType(artifact)
+        val tpe = (classifier, baseType) match {
+          case (Some(c), Some(tpe)) if Artifact.classifierType(c) == tpe => None
+          case _ => baseType
+        }
+        Some(makeDependencyElem(dependency, scope, optional, classifier, tpe))
+      } else None
     }
   def makeDependencyElem(dependency: DependencyDescriptor, scope: Option[String], optional: Boolean, classifier: Option[String], tpe: Option[String]): Elem =
     {