Add the concept of a higher level grouping for code.

Author: baffles

codepulse/src/main/resources/toserve/pages/traces/PackageController.js

@@ -34,7 +34,7 @@
 		// initialize the `stateTemplate` and `widgets` maps
 		// based on the package nodes in `treeData`
 		;(function setupTreeHierarchy(packageParentNode, node){
-			if(node.kind == 'package' || node.kind == 'root'){
+			if(node.kind == 'package' || node.kind == 'group' || node.kind == 'root'){
 
 				var pw = new PackageWidget()
 				widgets[node.id] = pw
@@ -62,7 +62,7 @@
 					pw.selectable(false)
 				}
 
-				if(node.kind == 'package'){
+				if(node.kind == 'group' || node.kind == 'package'){
 					if(packageParentNode){
 						widgets[packageParentNode.id].children.add(pw)
 					} else {
@@ -75,13 +75,16 @@
 						var parentName = packageParentNode ? packageParentNode.name : '',
 							abbrevName = node.name.substr(parentName.length)
 
+						if (packageParentNode && packageParentNode.kind == 'group')
+							abbrevName = abbrevName.substr(1)
+
 						pw.fullLabel(node.name).abbreviatedLabel(abbrevName)
 					}
 				}
 			}
 
 			;(node.children || []).forEach(function(kid){
-				var nextParent = (node.kind == 'package')? node : packageParentNode
+				var nextParent = (node.kind == 'group' || node.kind == 'package')? node : packageParentNode
 				setupTreeHierarchy(nextParent, kid)
 			})
 

codepulse/src/main/resources/toserve/pages/traces/TraceTreeData.js

@@ -34,7 +34,7 @@
 
 			treeProjector = new TreeProjector(d)
 
-			fullTree = treeProjector.projectFullTree(true /* generate self nodes for packages */)
+			fullTree = treeProjector.projectFullTree(false /* generate self nodes for packages */)
 
 			fullTree.forEachNode(true, function(n){
 				coverageSets[n.id] = d3.set()

codepulse/src/main/scala/com/secdec/codepulse/data/bytecode/CodeForestBuilder.scala

@@ -72,21 +72,21 @@ class CodeForestBuilder {
 		this
 	}
 
-	def getOrAddMethod(rawSig: String, size: Int): Option[CodeTreeNode] = {
-		MethodSignatureParser.parseSignature(rawSig) map { getOrAddMethod(_, size) }
+	def getOrAddMethod(group: String, rawSig: String, size: Int): Option[CodeTreeNode] = {
+		MethodSignatureParser.parseSignature(rawSig) map { getOrAddMethod(group, _, size) }
 	}
 
-	def getOrAddMethod(sig: MethodSignature, size: Int): CodeTreeNode = {
+	def getOrAddMethod(group: String, sig: MethodSignature, size: Int): CodeTreeNode = {
 		val treePath = CodePath.parse(sig)
-		val startNode = addRootPackage(treePath.name)
+		val startNode = addGroup(group)
 
 		def recurse(parent: CodeTreeNode, path: CodePath): CodeTreeNode = path match {
 			case CodePath.Package(name, childPath) => recurse(addChildPackage(parent, name), childPath)
 			case CodePath.Class(name, childPath) => recurse(addChildClass(parent, name), childPath)
 			case CodePath.Method(name) => addChildMethod(parent, name, size)
 		}
 
-		recurse(startNode, treePath.child)
+		recurse(startNode, treePath)
 	}
 
 	def getOrAddJsp(path: List[String], size: Int): CodeTreeNode = {
@@ -95,13 +95,13 @@ class CodeForestBuilder {
 			case packageNode :: rest => recurse(addChildPackage(parent, packageNode), rest)
 		}
 
-		recurse(addRootPackage("JSPs"), path)
+		recurse(addGroup("JSPs"), path)
 	}
 
-	protected def addRootPackage(name: String) = roots.find { node =>
-		node.name == name && node.kind == CodeTreeNodeKind.Pkg
+	protected def addGroup(name: String) = roots.find { node =>
+		node.name == name && node.kind == CodeTreeNodeKind.Grp
 	} getOrElse {
-		val node = nodeFactory.createPackageNode(name)
+		val node = nodeFactory.createGroupNode(name)
 		roots.add(node)
 		node
 	}

codepulse/src/main/scala/com/secdec/codepulse/data/bytecode/CodeTree2.scala

@@ -99,20 +99,26 @@ object CodeTreeNode {
 	}
 
 	def weightCriteria(node: CodeTreeNode) = node.kind match {
-		case CodeTreeNodeKind.Pkg => 0
-		case CodeTreeNodeKind.Cls => 1
-		case CodeTreeNodeKind.Mth => 2
+		case CodeTreeNodeKind.Grp => 0
+		case CodeTreeNodeKind.Pkg => 1
+		case CodeTreeNodeKind.Cls => 2
+		case CodeTreeNodeKind.Mth => 3
 	}
 
 }
 
 trait CodeTreeNodeFactory {
+	def createGroupNode(name: String): CodeTreeNode
 	def createPackageNode(name: String): CodeTreeNode
 	def createClassNode(name: String): CodeTreeNode
 	def createMethodNode(name: String, size: Int): CodeTreeNode
 }
 
 object CodeTreeNodeFactory {
+	private case class GroupNode(id: Int, name: String) extends CodeTreeNode {
+		def kind = CodeTreeNodeKind.Grp
+		def size = None
+	}
 	private case class PackageNode(id: Int, name: String) extends CodeTreeNode {
 		def kind = CodeTreeNodeKind.Pkg
 		def size = None
@@ -131,18 +137,21 @@ object CodeTreeNodeFactory {
 	class DefaultImpl extends CodeTreeNodeFactory {
 		val ids = Iterator from 0
 
+		def createGroupNode(name: String): CodeTreeNode = GroupNode(ids.next, name)
 		def createPackageNode(name: String): CodeTreeNode = PackageNode(ids.next, name)
 		def createClassNode(name: String): CodeTreeNode = ClassNode(ids.next, name)
 		def createMethodNode(name: String, size: Int): CodeTreeNode = MethodNode(ids.next, name, size)
 	}
 }
 sealed abstract class CodeTreeNodeKind(val label: String)
 object CodeTreeNodeKind {
+	case object Grp extends CodeTreeNodeKind("group")
 	case object Pkg extends CodeTreeNodeKind("package")
 	case object Cls extends CodeTreeNodeKind("class")
 	case object Mth extends CodeTreeNodeKind("method")
 
 	def unapply(label: String) = label match {
+		case Grp.label => Some(Grp)
 		case Pkg.label => Some(Pkg)
 		case Cls.label => Some(Cls)
 		case Mth.label => Some(Mth)

codepulse/src/main/scala/com/secdec/codepulse/data/trace/slick/TreeNodeDataDao.scala

@@ -33,6 +33,7 @@ private[slick] class TreeNodeDataDao(val driver: JdbcProfile) {
 
 	class TreeNodeData(tag: Tag) extends Table[TreeNode](tag, "tree_node_data") {
 		private val CodeTreeNodeKindMapping = Map[CodeTreeNodeKind, Char](
+			CodeTreeNodeKind.Grp -> 'g',
 			CodeTreeNodeKind.Pkg -> 'p',
 			CodeTreeNodeKind.Cls -> 'c',
 			CodeTreeNodeKind.Mth -> 'm')

codepulse/src/main/scala/com/secdec/codepulse/tracer/TraceUploadData.scala

@@ -110,14 +110,15 @@ object TraceUploadData {
 		//TODO: make this configurable somehow
 		val jspAdapter = new JasperJspAdapter
 
-		ZipEntryChecker.forEachEntry(file) { (entry, contents) =>
+		ZipEntryChecker.forEachEntry(file) { (filename, entry, contents) =>
+			val groupName = if (filename == file.getName) "\"classes\"" else new File(filename).getName
 			if (!entry.isDirectory) {
 				FilenameUtils.getExtension(entry.getName) match {
 					case "class" =>
 						val methods = AsmVisitors.parseMethodsFromClass(contents)
 						for {
 							(name, size) <- methods
-							treeNode <- builder.getOrAddMethod(name, size)
+							treeNode <- builder.getOrAddMethod(groupName, name, size)
 						} methodCorrelationsBuilder += (name -> treeNode.id)
 
 					case "jsp" =>

codepulse/src/main/scala/com/secdec/codepulse/util/ZipEntryChecker.scala

@@ -62,7 +62,7 @@ trait ZipEntryChecker {
 		case _ => false
 	}
 
-	def forEachEntry(file: File)(callback: (ZipEntry, InputStream) => Unit): Unit = {
+	def forEachEntry(file: File)(callback: (String, ZipEntry, InputStream) => Unit): Unit = {
 		Try { new ZipFile(file) } match {
 			// non-zip files don't work in this checker
 			case Failure(_) =>
@@ -81,14 +81,14 @@ trait ZipEntryChecker {
 								Stream.continually(zipStream.getNextEntry)
 									.takeWhile(_ != null)
 									.filterNot(ZipCleaner.shouldFilter)
-									.foreach { innerEntry => callback(innerEntry, zipStream) }
+									.foreach { innerEntry => callback(entry.getName, innerEntry, zipStream) }
 
 							} finally {
 								zipStream.close()
 							}
 						} else {
 							try {
-								callback(entry, stream)
+								callback(file.getName, entry, stream)
 							} finally {
 								stream.close
 							}