Java tutorial
/** * Copyright (c) 2011 Cloudsmith Inc. and other contributors, as listed below. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * Cloudsmith * */ package org.cloudsmith.geppetto.graph.dependency; import static org.cloudsmith.geppetto.forge.Forge.METADATA_JSON_NAME; import static org.cloudsmith.geppetto.forge.Forge.MODULEFILE_NAME; import static org.cloudsmith.geppetto.forge.v2.model.ModuleName.safeName; import static org.cloudsmith.geppetto.forge.v2.model.ModuleName.safeOwner; import java.io.File; import java.io.OutputStream; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Map; import java.util.Set; import org.cloudsmith.geppetto.diagnostic.Diagnostic; import org.cloudsmith.geppetto.diagnostic.DiagnosticType; import org.cloudsmith.geppetto.forge.v2.model.Dependency; import org.cloudsmith.geppetto.forge.v2.model.Metadata; import org.cloudsmith.geppetto.forge.v2.model.ModuleName; import org.cloudsmith.geppetto.graph.DependencyGraphProducer; import org.cloudsmith.geppetto.graph.IHrefProducer; import org.cloudsmith.geppetto.pp.PPPackage; import org.cloudsmith.geppetto.pp.pptp.PPTPPackage; import org.cloudsmith.geppetto.semver.Version; import org.cloudsmith.geppetto.semver.VersionRange; import org.cloudsmith.geppetto.validation.runner.AllModuleReferences; import org.cloudsmith.geppetto.validation.runner.AllModuleReferences.Export; import org.cloudsmith.geppetto.validation.runner.BuildResult; import org.cloudsmith.geppetto.validation.runner.MetadataInfo; import org.cloudsmith.graph.ICancel; import org.cloudsmith.graph.ICancel.NullIndicator; import org.cloudsmith.graph.IVertex; import org.cloudsmith.graph.dot.DotRenderer; import org.cloudsmith.graph.elements.Edge; import org.cloudsmith.graph.elements.GraphElement; import org.cloudsmith.graph.elements.RootGraph; import org.cloudsmith.graph.elements.Vertex; import org.cloudsmith.graph.graphcss.GraphCSS; import org.cloudsmith.graph.graphcss.IFunctionFactory; import org.cloudsmith.graph.graphcss.StyleSet; import org.cloudsmith.graph.style.IStyle; import org.cloudsmith.graph.style.IStyleFactory; import org.cloudsmith.graph.style.labels.LabelRow; import org.eclipse.emf.ecore.EClass; import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Multimap; import com.google.common.collect.Sets; import com.google.inject.Inject; /** * Calculates dependency data for a set of modules. The logic handles: * <ul> * <li>Existing and non existing modules</li> * <li>Resolved dependencies (stated in Modulefiles)</li> * <li>Unresolved dependencies (dependency on existing module, but unsatisfied version range).</li> * <li>Unresolved dependencies to missing modules (all versions aggregated into one 'missing module')</li> * <li>Implied 'dependencies' existing due to use of export from module</li> * <li>Self references are included in the result</li> * </ul> * Each module is represented by an instance of {@link ModuleNodeData}, and each relationship is represented * by an {@link ModuleEdge}. An edge is further described by an {@link EdgeType} as well as the implied meaning * of the given set of non null fields. It is up to the user of this data to decide how to represent multiple * edges, although it is suggested that a combination of resolved/implied is to be treated as "normal", and * unresolved/implied as "unresolved", if a dependency was not stated there may be only "implied" edges. * * For all unresolved references (not found anywhere), the edge leads to a "null" {@link ModuleEdge}. * */ public class DependencyDataCalculator implements DependencyGraphStyles, DependencyGraphProducer { public static enum EdgeType { UNRESOLVED, RESOLVED, IMPLIED; } public static class ModuleEdge { final ModuleNodeData from; final ModuleNodeData to; final EdgeType edgeType; final Iterable<Export> imported; final Iterable<String> unresolved; /** * null if edgeType == IMPLIED */ Dependency dependency; private Vertex vertex; /** * A (sub) collection of imported Exports that are ambiguous. May be null. */ final Collection<Export> ambiguities; /** * @param from * @param implied * @param unresolvedNames */ public ModuleEdge(ModuleNodeData from, EdgeType implied, Iterable<String> unresolvedNames) { this(from, null, implied, null, null, unresolvedNames, null); } public ModuleEdge(ModuleNodeData from, ModuleNodeData to, EdgeType type, Dependency d) { this(from, to, type, d, null, null, null); } public ModuleEdge(ModuleNodeData from, ModuleNodeData to, EdgeType type, Dependency d, Iterable<Export> imported, Iterable<String> unresolved, Collection<Export> ambiguities) { this.from = from; this.to = to; this.edgeType = type; this.dependency = d; this.imported = imported; this.unresolved = unresolved; this.ambiguities = ambiguities; from.addOutgoing(to, this); } /** * @param from * @param to * @param type * @param imported */ public ModuleEdge(ModuleNodeData from, ModuleNodeData to, EdgeType type, Iterable<Export> imported, Collection<Export> ambiguities) { this(from, to, type, null, imported, null, ambiguities); } public Vertex getVertex() { return vertex; } /** * @param edgeVertex */ public void setVertex(Vertex edgeVertex) { this.vertex = edgeVertex; } } public static class ModuleNodeData { public static ModuleNodeData existing(ModuleName name, Version version, boolean isNode, String href) { return new ModuleNodeData(name, version, isNode ? ModuleType.PPNODE : ModuleType.MODULE, href); } /** * Formats the label of the node as [NameOf(root.parent)/]NameOf(root) * * @param root * @return */ public static ModuleNodeData root(File root) { File parent = root.getParentFile(); ModuleName moduleName; if (parent != null) moduleName = new ModuleName(safeOwner(parent.getName()), safeName(root.getName(), false), false); else moduleName = new ModuleName("root", ModuleName.safeName(root.getName(), false), false); return new ModuleNodeData(moduleName, null, ModuleType.ROOT, ""); } public static ModuleNodeData unresolved(ModuleName name) { return new ModuleNodeData(name, null, ModuleType.NON_EXISTING, ""); } IVertex vertex; ModuleName name; Version version; ModuleType moduleType; String href; boolean marked; Multimap<ModuleNodeData, ModuleEdge> outgoing; private int ambiguous; private ModuleNodeData(ModuleName name, Version version, ModuleType type, String href) { this.name = name; this.version = version; this.moduleType = type; this.outgoing = ArrayListMultimap.create(); this.href = href; this.ambiguous = 0; } private void addOutgoing(ModuleNodeData to, ModuleEdge edge) { // filter out direct self references if (to == this) return; outgoing.put(to, edge); } public boolean exists() { return moduleType != ModuleType.NON_EXISTING; } private IVertex getVertex() { return vertex; } public boolean isAmbiguous() { return this.ambiguous > 0; } public boolean isNode() { return moduleType == ModuleType.PPNODE; } /** * mark all reachable module nodes. */ public void mark() { if (marked) return; marked = true; for (ModuleNodeData reachable : outgoing.keySet()) if (reachable != null) // i.e. if resolved reachable.mark(); } /** * @param b */ public void setAmbiguous(int counter) { this.ambiguous = counter; } private void setVertex(IVertex v) { vertex = v; } } public static enum ModuleType { ROOT, PPNODE, MODULE, NON_EXISTING, PPTP; } @Inject private IStyleFactory styles; @Inject private DependencyGraphTheme theme; @Inject private DotRenderer dotRenderer; @Inject private IHrefProducer hrefProducer; @Inject private GraphCSS instanceRules; private Map<Object, ModuleNodeData> moduleNodeData = Maps.newHashMap(); private List<ModuleEdge> moduleEdges = Lists.newArrayList(); private ModuleNodeData nonModularNode; private ModuleNodeData pptpNode; private File root; public static final DiagnosticType DEPENDENCY_DATA_CALCULATOR = new DiagnosticType("DEPENDENCY_DATA_CALCULATOR", DependencyDataCalculator.class.getName()); private ModuleNodeData _file2Module(File f, Map<File, ModuleNodeData> index) { String path = f.getPath(); ModuleNodeData md; if (path.endsWith(MODULEFILE_NAME) || path.endsWith(METADATA_JSON_NAME)) md = index.get(f); else { md = index.get(new File(path + '/' + MODULEFILE_NAME)); if (md == null) md = index.get(new File(path + '/' + METADATA_JSON_NAME)); } return md; } private void addEdgeHref(ModuleNodeData a, ModuleNodeData b, GraphElement... elements) { String aId = idOfVertex(a); String hrefForEdge = null; String bId = b == null || b == pptpNode ? "" : idOfVertex(b); boolean splitEdge = elements.length > 1; if (b == null) hrefForEdge = hrefProducer.hrefForEdgeToUnresolved(aId, splitEdge); else if (b == pptpNode) hrefForEdge = hrefProducer.hrefForEdgeToPptp(aId); else hrefForEdge = hrefProducer.hrefForEdge(aId, bId, splitEdge); IStyle<String> hrefStyle = styles.href(hrefForEdge); for (GraphElement e : elements) e.setStyles(StyleSet.withStyle(hrefStyle)); } private void addStyleClasses(List<String> classes, GraphElement... elements) { for (GraphElement e : elements) e.addAllStyleClasses(classes); } /** * Install tooltip as instance style for edge. * * @param tooltip * @param edges */ private void addTooltip(String tooltip, GraphElement... elements) { for (GraphElement e : elements) e.setStyles(StyleSet.withStyle(styles.tooltip(tooltip))); } /** * Calculates dependency data and returns a map from Modulefiles to ModuleNodeData. * * @param moduleData * @param exportData * @return */ public Map<File, ModuleNodeData> calculateDependencyData(File root, Multimap<ModuleName, MetadataInfo> moduleData, AllModuleReferences exportData) { // create node data for all existing modules and check if there are ambiguities Multimap<ModuleName, ModuleNodeData> processedModules = ArrayListMultimap.create(); for (MetadataInfo mi : moduleData.values()) { Metadata m = mi.getMetadata(); ModuleNodeData mnd = ModuleNodeData.existing(m.getName(), m.getVersion(), mi.isRole(), toHREF_URL(mi)); moduleNodeData.put(mi, mnd); processedModules.put(m.getName(), mnd); } for (ModuleName key : processedModules.keySet()) { Collection<ModuleNodeData> modules = processedModules.get(key); if (modules.size() > 1) { int counter = 0; for (ModuleNodeData mnd : modules) mnd.setAmbiguous(++counter); } } // moduleData is keyed by "fullName" to lower case // Create pseudo module for non modular content nonModularNode = ModuleNodeData.root(root); pptpNode = new ModuleNodeData(new ModuleName("root", "puppet", false), null, ModuleType.PPTP, ""); // will not be rendered // create module nodes for missing (unsatisfied dependencies) // unless dependency is to represented module name, but version is not matched (in which case // the unmatched but existing node is used. // if a dependency appears more than once, use the first (skip the rest with same name) for (MetadataInfo mi : moduleData.values()) { final ModuleNodeData a = moduleNodeData.get(mi); Set<ModuleName> processed = Sets.newHashSet(); for (Dependency d : mi.getUnresolvedDependencies()) { final ModuleName name = d.getName(); if (!processed.add(name)) continue; Collection<MetadataInfo> existingVersions = moduleData.get(name); ModuleNodeData b = null; if (existingVersions == null || existingVersions.size() < 1) { b = moduleNodeData.get(name); if (b == null) { // need a node for the missing module b = ModuleNodeData.unresolved(name); // need to generate one that can not be found if name is null moduleNodeData.put(name == null ? new ModuleName("no", "name", false) : name, b); } } else { // pick (one of) the existing versions (it is actually illegal to have more // than one, so just pick the first one). MetadataInfo first = Iterables.get(existingVersions, 0); b = moduleNodeData.get(first); } createUnresolvedEdge(a, b, d); } // Add edges for all resolved dependencies for (MetadataInfo.Resolution r : mi.getResolvedDependencies()) { createResolvedEdge(a, moduleNodeData.get(r.metadata), r.dependency); } } Map<File, ModuleNodeData> fileIndex = Maps.newHashMap(); for (Map.Entry<Object, ModuleNodeData> m : moduleNodeData.entrySet()) { if (!(m.getKey() instanceof ModuleName)) { MetadataInfo mi = (MetadataInfo) m.getKey(); fileIndex.put(mi.getFile(), m.getValue()); } } Map<File, Multimap<File, Export>> ambiguities = exportData.getAmbiguityMap(); for (Map.Entry<File, Multimap<File, AllModuleReferences.Export>> x : exportData.getImportMap().entrySet()) { // get the imported File fromFile = x.getKey(); Multimap<File, Export> m = x.getValue(); // get any ambiguities Multimap<File, Export> ambiguitiesForFile = ambiguities.get(fromFile); for (File toFile : m.keySet()) { createImportEdge(file2Module(fromFile, fileIndex), file2Module(toFile, fileIndex), m.get(toFile), ambiguitiesForFile != null ? ambiguitiesForFile.get(toFile) : null); } } for (File fromFile : exportData.getUnresolvedMap().keySet()) { createUnresolvedEdge(file2Module(fromFile, fileIndex), exportData.getUnresolvedMap().get(fromFile)); } return fileIndex; } private List<String> classesFor(ModuleNodeData from, ModuleNodeData to) { List<String> styleClasses = Lists.newArrayList(); if (from != null) styleClasses.add("FROM__" + idOfVertex(from)); if (to != null && to != pptpNode) styleClasses.add("TO__" + idOfVertex(to)); return styleClasses; } private List<String> classesOfEdge(ModuleEdge edge) { return classesFor(edge.from, edge.to); } private void createImportEdge(ModuleNodeData from, ModuleNodeData to, Iterable<Export> imported, Collection<Export> ambiguities) { moduleEdges.add(new ModuleEdge(from, to, EdgeType.IMPLIED, imported, ambiguities)); } private void createResolvedEdge(final ModuleNodeData a, final ModuleNodeData b, Dependency d) { moduleEdges.add(new ModuleEdge(a, b, EdgeType.RESOLVED, d)); } private void createUnresolvedEdge(ModuleNodeData from, Iterable<String> unresolvedNames) { moduleEdges.add(new ModuleEdge(from, EdgeType.IMPLIED, unresolvedNames)); } private void createUnresolvedEdge(final ModuleNodeData a, final ModuleNodeData b, Dependency d) { moduleEdges.add(new ModuleEdge(a, b, EdgeType.UNRESOLVED, d)); } private Vertex createVertexForEdge(ModuleEdge me) { if (me.imported == null && me.unresolved == null) // if neither imported nor unresolved, a vertex is not needed return null; StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append("References from "); stringBuilder.append(makeTooltip(me.from, me.to)); String tooltipString = stringBuilder.toString(); Vertex edgeVertex = null; if (me.imported != null) { edgeVertex = new Vertex("", STYLE_CLASS_IMPORTS); edgeVertex.setStyles(labelStyleForImported(me.imported, me.ambiguities) .add(StyleSet.withStyle(styles.tooltip(tooltipString)))); me.setVertex(edgeVertex); } else { edgeVertex = new Vertex("", STYLE_CLASS_UNRESOLVED_IMPORTS); edgeVertex .setStyles(labelStyleForUnresolved(me).add(StyleSet.withStyle(styles.tooltip(tooltipString)))); me.setVertex(edgeVertex); } // Set style classes for FROM and TO edgeVertex.addAllStyleClasses(classesOfEdge(me)); return edgeVertex; } private Vertex createVertexForModuleNode(ModuleNodeData mnd) { StringBuilder builder = new StringBuilder(); builder.append(mnd.name); if (mnd.isAmbiguous()) { builder.append(" ["); builder.append(mnd.ambiguous); builder.append("]"); } if (mnd.version != null) { builder.append("\n"); builder.append(mnd.version); } String label = builder.toString(); String style = mnd.exists() ? (mnd.isAmbiguous()) ? STYLE_CLASS_AMBIGUOUSLY_RESOLVED_MODULE : STYLE_CLASS_RESOLVED_MODULE : STYLE_CLASS_UNRESOLVED_MODULE; Vertex v = new Vertex(label, style); v.setStyles(styles.href(mnd.href)); v.putUserData(IFunctionFactory.ID_KEY, idOfVertex(mnd)); mnd.setVertex(v); return v; } private Vertex createVertexForPPNodeNode(ModuleNodeData mnd) { String label = mnd.name == null ? "" : mnd.name.toString(); // no version (user is not aware of one). String style = STYLE_CLASS_PPNODE_MODULE; Vertex v = new Vertex(label, style); v.setStyles(styles.href(mnd.href)); v.putUserData(IFunctionFactory.ID_KEY, idOfVertex(mnd)); mnd.setVertex(v); return v; } private Vertex createVertexForRootNode(ModuleNodeData mnd) { String label = mnd.name.toString(); if (mnd.version != null) label += "\n" + mnd.version; Vertex v = new Vertex(label, STYLE_CLASS_ROOT); mnd.setVertex(v); return v; } protected void dumpInfo() { for (ModuleNodeData m : moduleNodeData.values()) { System.err.printf("module %s(%s) = %s\n", m.name, m.version, m.exists() ? "exists" : "missing"); for (ModuleNodeData to : m.outgoing.keySet()) { System.err.printf(" -> %s\n", to != null ? to.name : "null 'to'"); for (ModuleEdge edge : m.outgoing.get(to)) { System.err.printf(" %s, ", edge.edgeType); if (edge.imported != null) for (Export e : edge.imported) System.err.printf("%s ", e.getName()); if (edge.unresolved != null) for (String s : edge.unresolved) System.err.printf("(unresolved) %s ", s); if (edge.imported != null || edge.unresolved != null) System.err.println(); if (edge.dependency != null) if (edge.dependency.getVersionRequirement() == null) System.err.println(">= 0"); else System.err.printf("%s\n", edge.dependency.getVersionRequirement()); } } } } private ModuleNodeData file2Module(File f, Map<File, ModuleNodeData> index) { if (f.getPath().equals("_pptp")) return pptpNode; ModuleNodeData mnd = _file2Module(f, index); return mnd != null ? mnd : nonModularNode; } public String getVersionLabel(ModuleEdge edge) { VersionRange vreq = edge.dependency.getVersionRequirement(); if (vreq == null) return "unversioned"; return vreq.toString(); } /** * Produce id on the form NAME[@ambiguityIdx] e.g. Foo, Bar-1, Bar-2 * * @param mnd * @return */ private String idOfVertex(ModuleNodeData mnd) { StringBuilder idBuilder = new StringBuilder(); idBuilder.append(mnd.name); if (mnd.isAmbiguous()) { idBuilder.append("__"); idBuilder.append(mnd.ambiguous); } return idBuilder.toString(); } private String labelOfType(EClass clazz) { if (clazz == PPPackage.Literals.DEFINITION) return "define"; if (clazz == PPPackage.Literals.HOST_CLASS_DEFINITION) return "class"; if (clazz == PPPackage.Literals.NODE_DEFINITION) return "node"; if (clazz == PPTPPackage.Literals.FUNCTION) return "function"; if (clazz == PPTPPackage.Literals.TYPE) return "type"; return clazz.getName(); // give up, but output something (should not really happen) } private StyleSet labelStyleForImported(Iterable<Export> imports, Collection<Export> ambiguities) { List<LabelRow> labelRows = Lists.newArrayList(); Export[] sortedImports = Iterables.toArray(imports, Export.class); Arrays.sort(sortedImports, new Comparator<Export>() { @Override public int compare(Export o1, Export o2) { // they are not supposed to be null, but just to make sure we don't get a NPE // because of a bug elsewhere if (o1 == null || o2 == null) return 0; return o1.getName().compareTo(o2.getName()); } }); for (Export a : sortedImports) { if (a == null) { System.err.println("Null Export found"); continue; } final boolean ambiguous = ambiguities == null ? false : ambiguities.contains(a); labelRows.add(styles.labelRow(STYLE__IMPORT_ROW, // styles.labelCell( // ambiguous ? STYLE__IMPORT_AMBIGUOUS_NAME_CELL : STYLE__IMPORT_NAME_CELL, // a.getName()).withStyle(// styles.href(toHREF_URL(a))), // styles.labelCell(STYLE__IMPORT_TYPE_CELL, labelOfType(a.getEClass())))); } return StyleSet.withStyle( styles.labelFormat(styles.labelTable(STYLE__IMPORT_TABLE, labelRows.toArray(new LabelRow[0])))); } private StyleSet labelStyleForUnresolved(ModuleEdge me) { Iterable<String> unresolved = me.unresolved; List<LabelRow> labelRows = Lists.newArrayList(); String[] sortedImports = Iterables.toArray(unresolved, String.class); Arrays.sort(sortedImports, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareTo(o2); } }); for (String a : sortedImports) { labelRows.add(styles.labelRow(STYLE__UNRESOLVED_ROW, // styles.labelCell(STYLE__UNRESOLVED_NAME_CELL, a).withStyle( // styles.href(toHREF_UNRESOLVED(me.from.name, a))) // )); } return StyleSet.withStyle( styles.labelFormat(styles.labelTable(STYLE__IMPORT_TABLE, labelRows.toArray(new LabelRow[0])))); } /** * @param a * @param b * @return */ private String makeTooltip(ModuleNodeData a, ModuleNodeData b) { final StringBuilder tooltipBuilder = new StringBuilder(); tooltipBuilder.append(a.name); tooltipBuilder.append(" ⇒ "); // i.e. ⇒ a non defined entity in SVG if (b != null) tooltipBuilder.append(b.name); return tooltipBuilder.toString(); } public void produceGraph(ICancel cancel, String title, File[] roots, OutputStream output, BuildResult buildResult, Diagnostic chain) { if (title == null) title = "Module Dependencies"; AllModuleReferences all = buildResult.getAllModuleReferences(); produceGraph(cancel, title, roots, output, all.getRoot(), buildResult.getModuleData(), all, chain); } /** * * @param root * @param moduleData * Name -> 0* MetadataInfo representing one version of a module with given name */ public void produceGraph(ICancel cancel, String title, File[] roots, OutputStream output, File root, Multimap<ModuleName, MetadataInfo> moduleData, AllModuleReferences exportData, Diagnostic chain) { if (cancel == null) cancel = new NullIndicator(); this.root = root; Map<File, ModuleNodeData> fileMap = calculateDependencyData(root, moduleData, exportData); // Render all unless there is a list of roots to include. If roots are given, mark their // transitive closures, and tell renderer to render only those that are marked. boolean renderAll = roots == null || roots.length == 0; if (!renderAll) for (File f : roots) { ModuleNodeData x = file2Module(f, fileMap); if (x != null) x.mark(); } else { // mark all for (ModuleNodeData x : fileMap.values()) x.mark(); } RootGraph g = produceRootGraph(cancel, title, moduleData, exportData, renderAll, chain); instanceRules.addAll(theme.getInstanceRules()); dotRenderer.write(cancel, output, g, theme.getDefaultRules(), instanceRules); } /** * Produces the graph with vertex and edge data. If renderAll is false, only marked ModuleNodeData * will be rendered. * * @param title * @param moduleData * @param exportData * @param renderAll * @return */ private RootGraph produceRootGraph(ICancel cancel, String title, Multimap<ModuleName, MetadataInfo> moduleData, AllModuleReferences exportData, boolean renderAll, Diagnostic chain) { if (title == null) title = ""; if (cancel == null) cancel = new NullIndicator(); RootGraph g = new RootGraph(title, "RootGraph", "root"); // Create Graph vertexes, one per existing module // and one for the root/non-modular for (ModuleNodeData mnd : moduleNodeData.values()) { cancel.assertContinue(); if (renderAll || mnd.marked) if (mnd.isNode()) g.addVertex(createVertexForPPNodeNode(mnd)); else g.addVertex(createVertexForModuleNode(mnd)); } // only draw the root node if it has been marked (incoming dependency), or has outgoing // when not rendering all, the non modular must have incoming dependencies to show. if (renderAll && nonModularNode.outgoing.size() > 0 || nonModularNode.marked) { Vertex v = createVertexForRootNode(nonModularNode); g.addVertex(v); } // Create Vertexes for all Edges that have data // (very large labels on edges does not work that well as they often overlap) // Skip edges that are from non marked module nodes unless everything is rendered for (ModuleEdge me : moduleEdges) { // filter out self references if (me.from == me.to) continue; if (renderAll || me.from.marked) { cancel.assertContinue(); Vertex v = createVertexForEdge(me); if (v != null) { g.addVertex(v); } } } // Create Edges // If an edge has a vertex, it needs to be drawn as two separate graph edges for (ModuleNodeData a : Iterables.concat(moduleNodeData.values(), Collections.singleton(nonModularNode))) { if (!(renderAll || a.marked)) continue; // skip non marked unless all is rendered for (ModuleNodeData b : a.outgoing.keySet()) { cancel.assertContinue(); int resolved = 0; int unresolved = 0; int implied = 0; int count = 0; List<ModuleEdge> edges = new ArrayList<ModuleEdge>(); Collection<ModuleEdge> outgoing = a.outgoing.get(b); for (ModuleEdge e : outgoing) { edges.add(e); switch (e.edgeType) { case IMPLIED: implied++; break; case UNRESOLVED: unresolved++; break; case RESOLVED: resolved++; break; default: throw new IllegalStateException("Illegal edge type found"); } ++count; } String tooltipString = makeTooltip(a, b); List<String> styleClasses = classesFor(a, b); // CASE 1 // A --> [...] --> B // A imports from resolved B if (count == 2 && resolved == 1 && implied == 1) { Edge e1 = new Edge("", STYLE_EDGE__IMPORT, a.getVertex(), edges.get(1).getVertex()); Edge e2 = new Edge(getVersionLabel(edges.get(0)), STYLE_EDGE__RESOLVED_DEP, // edges.get(1).getVertex(), b.getVertex()); g.addEdge(e1, e2); addTooltip(tooltipString, e1, e2); addStyleClasses(styleClasses, e1, e2); addEdgeHref(a, b, e1, e2); } else if (count == 1 && implied == 1) { // CASE 5 // A --> [...] if (edges.get(0).to == null) { Edge e1 = new Edge("unresolved", STYLE_EDGE__UIMPORT, a.getVertex(), edges.get(0).getVertex()); g.addEdge(e1); addTooltip(tooltipString, e1); addStyleClasses(styleClasses, e1); addEdgeHref(a, b, e1); } // CASE 8 (reference to pptp - do not draw imports -> pptp part) // A -->[...] else if (edges.get(0).to == pptpNode) { Edge e1 = new Edge("puppet", STYLE_EDGE__IMPORT, a.getVertex(), edges.get(0).getVertex()); g.addEdge(e1); // default tooltip == label addStyleClasses(styleClasses, e1); addEdgeHref(a, b, e1); } // CASE 2 (and CASE 0 - self reference) // A -->[...] ~~> B else { if (edges.get(0).from != edges.get(0).to) { // skip self references Edge e1 = new Edge("", STYLE_EDGE__IMPORT, a.getVertex(), edges.get(0).getVertex()); Edge e2 = new Edge("implicit", STYLE_EDGE__IMPLIED_DEP, edges.get(0).getVertex(), edges.get(0).to.getVertex()); g.addEdge(e1, e2); addTooltip(tooltipString, e1, e2); addStyleClasses(styleClasses, e1, e2); addEdgeHref(a, b, e1, e2); } } } // CASE 3 // A --> [...] ~~>(not in range) B else if (count == 2 && implied == 1 && unresolved == 1) { Edge e1 = new Edge("", STYLE_EDGE__IMPORT, a.getVertex(), edges.get(1).getVertex()); String label = "implicit\\nunresolved\\n" + getVersionLabel(edges.get(0)); Edge e2 = new Edge(label, STYLE_EDGE__UNRESOLVED_IMPLIED_DEP, // edges.get(1).getVertex(), edges.get(1).to.getVertex()); g.addEdge(e1, e2); addTooltip(tooltipString, e1, e2); addStyleClasses(styleClasses, e1, e2); addEdgeHref(a, b, e1, e2); } else if (count == 1 && unresolved == 1) { // CASE 7 // A ~~> B where B is not in range if (edges.get(0).to.exists()) { String label = "unresolved\\n" + getVersionLabel(edges.get(0)); Edge e1 = new Edge(label, STYLE_EDGE__UNRESOLVED_IMPLIED_DEP, // a.getVertex(), b.getVertex()); g.addEdge(e1); addTooltip(tooltipString, e1); addStyleClasses(styleClasses, e1); addEdgeHref(a, b, e1); } // CASE 4 // A --> B where B does not exist else { String label = "unresolved\\n" + getVersionLabel(edges.get(0)); Edge e1 = new Edge(label, STYLE_EDGE__UNRESOLVED_DEP, // a.getVertex(), b.getVertex()); g.addEdge(e1); addTooltip(tooltipString, e1); addStyleClasses(styleClasses, e1); addEdgeHref(a, b, e1); } } // CASE 6 // A --> B // (nothing is imported from B) else if (count == 1 && resolved == 1) { Edge e1 = new Edge(getVersionLabel(edges.get(0)), STYLE_EDGE__RESOLVED_DEP, // a.getVertex(), b.getVertex()); g.addEdge(e1); addTooltip(tooltipString, e1); addStyleClasses(styleClasses, e1); addEdgeHref(a, b, e1); } else if (count == implied) { // TODO: Figure out what this means. It happens when importing puppetlabs/stdlib into // cloudsmith/wordpress: // // a=thallgren/wordpress // b=root/puppet } else { // StringBuilder builder = new StringBuilder(); // builder.append("Internal Error - illegal combination of recorded edges"); // builder.append(" count="); // builder.append(count); // builder.append(" resolved="); // builder.append(resolved); // builder.append(" unresolved="); // builder.append(unresolved); // builder.append(" a ="); // builder.append(a.name); // builder.append(" b="); // builder.append(b == null // ? "implied" // : b.name); // chain.addChild(new Diagnostic(Diagnostic.ERROR, DEPENDENCY_DATA_CALCULATOR, builder.toString())); } } } return g; } public String toHREF_UNRESOLVED(ModuleName fromModuleName, String name) { return hrefProducer.hrefForUnresolved(fromModuleName, name); } private String toHREF_URL(Export e) { return hrefProducer.href(e, this.root); } public String toHREF_URL(MetadataInfo mi) { return hrefProducer.href(mi, this.root); } }