github-mirrors/odc-analyzer
1
0
Fork 0
mirror of https://github.com/ysoftdevs/odc-analyzer.git synced 2026-01-15 16:23:52 +01:00
Code Issues 2 Packages Projects Releases Wiki Activity

Filtering by team is now more failsafe

Browse Source
This commit is contained in:
Šesták Vít
2016-08-24 23:31:10 +02:00
parent 990bafd29b
commit 5edf9f0781
2 changed files with 27 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
app/controllers/DependencyCheckReportsParser.scala
View File

@@ -45,6 +45,15 @@ private final case class ProjectFilter(project: ReportInfo) extends Filter{
}
private final case class TeamFilter(team: Team) extends Filter{
override def filters: Boolean = true
private def splitSuccessesAndFailures[T, U](set: Set[Either[T, U]]) = {
val (lefts, rights) = set.partition(_.isLeft)
(
lefts.map(_.asInstanceOf[Left[T, U]].a),
rights.map(_.asInstanceOf[Right[T, U]].b)
)
}
override def subReports(r: Result): Option[Result] = {
val Wildcard = """^(.*): \*$""".r
@inline def toMapStrict[K, V](l: Traversable[(K, V)]) = l.toSeq.groupBy(_._1).mapValues{ // without toSeq, the pattern matching might fail
@@ -62,16 +71,22 @@ private final case class TeamFilter(team: Team) extends Filter{
if(failedProjectsFriendlyNames contains name) Seq()
else sys.error("Unknown project: "+name)
)
def reportInfoByFriendlyProjectName(fpn: String) = fpn match{
case Wildcard(rfpn) => rootProjectReports(rfpn)
case _ => Set(reportInfoByFriendlyProjectNameMap(fpn))
def reportInfoByFriendlyProjectName(fpn: String): Either[Iterable[ReportInfo], String] = {
def toEither[T](v: Option[T]): Either[T, String] = v.fold[Either[T, String]](Right(fpn))(Left(_))
fpn match{
case Wildcard(rfpn) => toEither(rootProjectReports.get(rfpn))
case _ => toEither(reportInfoByFriendlyProjectNameMap.get(fpn).map(Set(_)))
}
}
val reportInfos = team.projectNames.flatMap(reportInfoByFriendlyProjectName)
val (reportInfosDeep, projectsNotFound) = splitSuccessesAndFailures(team.projectNames.map(reportInfoByFriendlyProjectName))
val reportInfos: Set[ReportInfo] = reportInfosDeep.flatten
def submap[T](m: Map[ReportInfo, T]) = reportInfos.toSeq.flatMap(ri => m.get(ri).map(ri -> _) ).toMap
def submapBare[T](m: Map[ReportInfo, T]): Map[ReportInfo, T] = reportInfos.toSeq.flatMap(ri => m.get(ri.bare.ensuring{x => println(x.fullId); true}).map(ri -> _) ).toMap
// TODO: projectsNotFoundMap is a hack for reporting errors to humans, because there is no suitable category for such errors
val projectsNotFoundMap = projectsNotFound.map(name => ReportInfo("name: " + name, name, "name: " + name, None) -> new RuntimeException("Project " + name + " not found")).toMap
Some(Result(
bareFlatReports = submap(r.bareFlatReports),
bareFailedAnalysises = submapBare(r.bareFailedAnalysises),
bareFailedAnalysises = submapBare(r.bareFailedAnalysises) ++ projectsNotFoundMap,
projectsReportInfo = r.projectsReportInfo,
failedReportDownloads = submapBare(r.failedReportDownloads)
))

14
app/controllers/Projects.scala
View File

@@ -11,9 +11,9 @@ class Projects @Inject() (configuration: Configuration) {
projectsConfig.entrySet().map( k => k.getKey -> projectsConfig.getString(k.getKey)).toMap
}
val projectSet = projectMap.keySet
val teamIdSet = configuration.getStringSeq("yssdc.teams").getOrElse(sys.error("yssdc.teams is not set")).map(TeamId).toSet
private val teamIdSet = configuration.getStringSeq("yssdc.teams").getOrElse(sys.error("yssdc.teams is not set")).map(TeamId).toSet
private val teamsByIds = teamIdSet.map(t => t.id -> t).toMap
val teamLeaders = {
private val teamLeaders = {
import scala.collection.JavaConversions._
configuration.getObject("yssdc.teamLeaders").getOrElse(sys.error("yssdc.teamLeaders is not set")).map{case(k, v) =>
TeamId(k) -> v.unwrapped().asInstanceOf[String]
@@ -26,17 +26,17 @@ class Projects @Inject() (configuration: Configuration) {
}
}
def existingTeamId(s: String): TeamId = teamsByIds(s)
private def existingTeamId(s: String): TeamId = teamsByIds(s)
val projectToTeams = configuration.getObject("yssdc.projectsToTeams").get.mapValues{_.unwrapped().asInstanceOf[java.util.List[String]].map(c =>
private val projectToTeams = configuration.getObject("yssdc.projectsToTeams").get.mapValues{_.unwrapped().asInstanceOf[java.util.List[String]].map(c =>
existingTeamId(c)
).toSet}.map(identity)
val projectAndTeams = projectToTeams.toSeq.flatMap{case (project, teams) => teams.map(team => (project, team))}
private val projectAndTeams = projectToTeams.toSeq.flatMap{case (project, teams) => teams.map(team => (project, team))}
val teamsToProjects = projectAndTeams.groupBy(_._2).mapValues(_.map(_._1).toSet).map(identity)
private val teamsToProjects = projectAndTeams.groupBy(_._2).mapValues(_.map(_._1).toSet).map(identity)
val teamsById: Map[String, Team] = for{
private val teamsById: Map[String, Team] = for{
(team, projectNames) <- teamsToProjects
} yield team.id -> Team(
id = team.id,