Change formatter plugin to @diffplug's Spotless plugin

Advantages of Spotless over current solution:
- Error messages are (in my opinion) easier to understand.
- We can easily adopt other formatters in the future, such as a
  formatter which checks that files have license headers that follow
  a certain template.

Author: jbduncan

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/algorithms/generators/Lattice2DGenerator.java

@@ -52,7 +52,8 @@ public class Lattice2DGenerator<N, E> {
    * @param toroidal
    */
   public Lattice2DGenerator(int rowCount, int colCount, boolean toroidal) {
-    // TODO: relax the row/col count restrictions to be >= 3 once we get the random selection mechanism
+    // TODO: relax the row/col count restrictions to be >= 3 once we get the random selection
+    // mechanism
     // in KleinbergSmallWorld to behave better
     Preconditions.checkArgument(rowCount >= 4, "row count must be >= 4");
     Preconditions.checkArgument(colCount >= 4, "column count must be >= 4");

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/algorithms/generators/random/KleinbergSmallWorld.java

@@ -1,4 +1,3 @@
-
 package edu.uci.ics.jung.algorithms.generators.random;
 
 /*
@@ -110,7 +109,8 @@ public void addSmallWorldConnections(
     // without creating parallel edges or self-loops (both are disallowed)
     Preconditions.checkArgument(graph.nodes().size() - 5 >= connectionCount);
 
-    // TODO: For toroidal graphs, we can make this more clever by pre-creating the WeightedChoice object
+    // TODO: For toroidal graphs, we can make this more clever by pre-creating the WeightedChoice
+    // object
     // and using the output as an offset to the current node location.
 
     for (N node : graph.nodes()) {
@@ -124,7 +124,8 @@ public void addSmallWorldConnections(
       while (targets.size() < connectionCount) {
         // the item returned is guaranteed by getWeightedChoiceForDistance() to not be equal to node
         // or any of its successors; we may try to add the same node to targets more than once
-        // (see the note above re: selection w/o replacement) but the Set semantics disallows duplicates
+        // (see the note above re: selection w/o replacement) but the Set semantics disallows
+        // duplicates
         targets.add(weightedChoice.nextItem());
       }
 

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/algorithms/scoring/WeightedNIPaths.java

@@ -40,7 +40,8 @@
 // TODO: versions for Graph/ValueGraph
 // TODO: extend AbstractIterativeScorer and provide for iterating one step (depth) at a time?
 // TODO: review this and make sure it's correctly implementing the algorithm
-// TODO: this takes in a MutableNetwork and factories as a hack; there's got to be a better way; options include:
+// TODO: this takes in a MutableNetwork and factories as a hack; there's got to be a better way;
+// options include:
 // (1) create a delegate class that pretends that the extra node/edge are there
 // (2) refactor the internal logic so that we can emulate the presence of that node/edge
 public class WeightedNIPaths<N, E> implements NodeScorer<N, Double> {

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/algorithms/shortestpath/DijkstraShortestPath.java

@@ -152,7 +152,8 @@ public List<E> getPath(N source, N target) {
     Preconditions.checkArgument(
         g.nodes().contains(source), "Specified source node %s  is not part of graph %s", source, g);
 
-    // TODO: Consider replacing this with an `ArrayList` (http://errorprone.info/bugpattern/JdkObsolete)
+    // TODO: Consider replacing this with an `ArrayList`
+    // (http://errorprone.info/bugpattern/JdkObsolete)
     LinkedList<E> path = new LinkedList<E>();
 
     // collect path data; must use internal method rather than

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/algorithms/shortestpath/MinimumSpanningTree.java

@@ -25,7 +25,8 @@
  * @param <E> the edge type
  */
 public class MinimumSpanningTree<N, E> {
-  // TODO: consider providing a separate mechanism for extracting a spanning tree from an unweighted graph.
+  // TODO: consider providing a separate mechanism for extracting a spanning tree from an unweighted
+  // graph.
 
   /**
    * Extracts a minimum spanning forest from {@code graph} based on the specified edge weights. (If

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/layout/algorithms/DAGLayoutAlgorithm.java

@@ -211,7 +211,7 @@ protected void moveNodes() {
         setLocation(node, posX, posY);
       }
     }
-    //System.out.println("MeanSquareAccel="+meanSquareVel);
+    // System.out.println("MeanSquareAccel="+meanSquareVel);
     if (!stoppingIncrements && Math.abs(meanSquareVel - oldMSV) < MSV_THRESHOLD) {
       stoppingIncrements = true;
       incrementsLeft = COOL_DOWN_INCREMENTS;

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/layout/algorithms/ISOMLayoutAlgorithm.java

@@ -95,14 +95,14 @@ public void initialize() {
     adaption = initialAdaption;
     minAdaption = 0;
 
-    //factor = 0; //Will be set later on
+    // factor = 0; //Will be set later on
     coolingFactor = 2;
 
-    //temperature = 0.03;
-    //initialJumpRadius = 100;
-    //jumpRadius = initialJumpRadius;
+    // temperature = 0.03;
+    // initialJumpRadius = 100;
+    // jumpRadius = initialJumpRadius;
 
-    //delay = 100;
+    // delay = 100;
   }
 
   /** Advances the current positions of the graph elements. */
@@ -123,11 +123,11 @@ public void step() {
   private synchronized void adjust() {
     double width = layoutModel.getWidth();
     double height = layoutModel.getHeight();
-    //Generate random position in graph space
+    // Generate random position in graph space
     // creates a new XY data location
     Point tempXYD = Point.of(10 + Math.random() * width, 10 + Math.random() * height);
 
-    //Get closest node to random position
+    // Get closest node to random position
     N winner = elementAccessor.getNode(layoutModel, tempXYD.x, tempXYD.y);
 
     while (true) {
@@ -148,8 +148,8 @@ private synchronized void updateParameters() {
     epoch++;
     double factor = Math.exp(-1 * coolingFactor * (1.0 * epoch / maxEpoch));
     adaption = Math.max(minAdaption, factor * initialAdaption);
-    //jumpRadius = (int) factor * jumpRadius;
-    //temperature = factor * temperature;
+    // jumpRadius = (int) factor * jumpRadius;
+    // temperature = factor * temperature;
     if ((radius > minRadius) && (epoch % radiusConstantTime == 0)) {
       radius--;
     }

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/layout/algorithms/KKLayoutAlgorithm.java

@@ -160,7 +160,7 @@ public void initialize() {
 
       double L0 = Math.min(height, width);
       L = (L0 / diameter) * length_factor; // length_factor used to be hardcoded to 0.9
-      //L = 0.75 * Math.sqrt(height * width / n);
+      // L = 0.75 * Math.sqrt(height * width / n);
 
       for (int i = 0; i < n - 1; i++) {
         for (int j = i + 1; j < n; j++) {

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/layout/algorithms/TreeLayoutAlgorithm.java

@@ -101,7 +101,7 @@ protected void buildTree(LayoutModel<N> layoutModel) {
   protected void buildTree(LayoutModel<N> layoutModel, N node, int x) {
 
     if (alreadyDone.add(node)) {
-      //go one level further down
+      // go one level further down
       double newY = this.currentY + this.distY;
       this.currentX = x;
       this.currentY = newY;

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/layout/model/AbstractLayoutModel.java

@@ -215,7 +215,7 @@ public void setSize(int width, int height) {
     }
 
     if (oldWidth != 0 || oldHeight != 0) {
-      adjustLocations(oldWidth, oldHeight, width, height); //, size);
+      adjustLocations(oldWidth, oldHeight, width, height); // , size);
     }
     this.width = width;
     this.height = height;

Diff for: jung-algorithms/src/main/java/edu/uci/ics/jung/layout/spatial/Node.java

@@ -109,7 +109,7 @@ public void insert(ForceObject<T> element) {
       }
       // we're already split, update the forceElement for this new element
       forceObject = forceObject.add(element);
-      //and follow down the tree to insert
+      // and follow down the tree to insert
       insertForceObject(element);
     }
   }

Diff for: jung-algorithms/src/test/java/edu/uci/ics/jung/algorithms/generators/random/TestEppsteinPowerLawGenerator.java

@@ -53,7 +53,8 @@ public void testSimpleDirectedCase() {
   //    public void testPowerLawProperties() {
   //
   //        //long start = System.currentTimeMillis();
-  //        EppsteinPowerLawGenerator generator = new EppsteinPowerLawGenerator(nodeFactory, edgeFactory,
+  //        EppsteinPowerLawGenerator generator = new EppsteinPowerLawGenerator(nodeFactory,
+  // edgeFactory,
   //        		500,1500,100000);
   //        generator.setSeed(5);
   //        Graph graph = (Graph) generator.generateGraph();
@@ -64,20 +65,24 @@ public void testSimpleDirectedCase() {
   //        int maxDegree = (int) Descriptive.max(degreeList);
   //        Histogram degreeHistogram = GraphStatistics.createHistogram(degreeList,0,maxDegree,1);
   //        //for (int index=0;index<maxDegree;index++) {
-  //        //    System.out.println(degreeHistogram.binIndex(index) + " " + degreeHistogram.binHeight(index));
+  //        //    System.out.println(degreeHistogram.binIndex(index) + " " +
+  // degreeHistogram.binHeight(index));
   //        //}
   //        //if it's power law, 0 is going to have the highest bin count
-  //        Assert.assertTrue(degreeHistogram.binHeight(0) + degreeHistogram.binHeight(1) > degreeHistogram.binHeight(2) + degreeHistogram.binHeight(3));
+  //        Assert.assertTrue(degreeHistogram.binHeight(0) + degreeHistogram.binHeight(1) >
+  // degreeHistogram.binHeight(2) + degreeHistogram.binHeight(3));
   //
   //        generator = new EppsteinPowerLawGenerator(500,1500,0);
   //        graph = (Graph) generator.generateGraph();
   //        degreeList = DegreeDistributions.getOutdegreeValues(graph.getNodes());
   //        maxDegree = (int) Descriptive.max(degreeList);
   //        degreeHistogram = GraphStatistics.createHistogram(degreeList,0,maxDegree,1);
   //        //for (int index=0;index<maxDegree;index++) {
-  //        //    System.out.println(degreeHistogram.binIndex(index) + " " + degreeHistogram.binHeight(index));
+  //        //    System.out.println(degreeHistogram.binIndex(index) + " " +
+  // degreeHistogram.binHeight(index));
   //        //}
-  //        //if it's not power law, 0 is not going to have the highest bin count rather it will start to go up
+  //        //if it's not power law, 0 is not going to have the highest bin count rather it will
+  // start to go up
   //        Assert.assertTrue(degreeHistogram.binHeight(0) < degreeHistogram.binHeight(1));
   //
   //

Diff for: jung-algorithms/src/test/java/edu/uci/ics/jung/algorithms/scoring/TestHITS.java

@@ -59,7 +59,8 @@ public void testRanker() {
       //            Assert.assertEquals(t.transform(1).hub,
       //            		ranker.getAuthScore(2) + 0.2*ranker.getAuthScore(4));
       //            Assert.assertEquals(t.transform(2).hub,
-      //            		0.5*ranker.getAuthScore(1) + ranker.getAuthScore(3) + 0.2*ranker.getAuthScore(4));
+      //            		0.5*ranker.getAuthScore(1) + ranker.getAuthScore(3) +
+      // 0.2*ranker.getAuthScore(4));
       //            Assert.assertEquals(t.transform(3).hub,
       //            		ranker.getAuthScore(0) + 0.2*ranker.getAuthScore(4));
       //            Assert.assertEquals(t.transform(4).hub,
@@ -69,7 +70,8 @@ public void testRanker() {
       //            Assert.assertEquals(t.transform(0).authority,
       //            		ranker.getNodeScore(3) + 0.2*ranker.getNodeScore(4));
       //            Assert.assertEquals(t.transform(1).authority,
-      //            		ranker.getNodeScore(0) + 0.5 * ranker.getNodeScore(2) + 0.2*ranker.getNodeScore(4));
+      //            		ranker.getNodeScore(0) + 0.5 * ranker.getNodeScore(2) +
+      // 0.2*ranker.getNodeScore(4));
       //            Assert.assertEquals(t.transform(2).authority,
       //            		ranker.getNodeScore(1) + 0.2*ranker.getNodeScore(4));
       //            Assert.assertEquals(t.transform(3).authority,

Diff for: jung-api/src/main/java/edu/uci/ics/jung/graph/TreeBuilder.java

@@ -72,7 +72,8 @@ public <N1 extends N> TreeBuilder<N1> nodeOrder(ElementOrder<N1> nodeOrder) {
   /** Returns an empty {@link MutableCTree} with the properties of this {@link TreeBuilder}. */
   // TODO(jrtom): decide how we're going to handle different implementations.
   // For the graph stuff, we don't really need different implementations, but
-  // for trees, maybe we do; at least for binary trees vs. trees with no restrictions on outgoing edges...
+  // for trees, maybe we do; at least for binary trees vs. trees with no restrictions on outgoing
+  // edges...
   public <N1 extends N> MutableCTree<N1> build() {
     GraphBuilder<Object> graphBuilder = GraphBuilder.directed().allowsSelfLoops(false);
     if (expectedNodeCount.isPresent()) {

Diff for: jung-api/src/main/java/edu/uci/ics/jung/graph/TreeNetworkBuilder.java

@@ -80,7 +80,8 @@ public <E1 extends E> TreeNetworkBuilder<N, E1> edgeOrder(ElementOrder<E1> edgeO
    */
   // TODO(jrtom): decide how we're going to handle different implementations.
   // For the graph stuff, we don't really need different implementations, but
-  // for trees, maybe we do; at least for binary trees vs. trees with no restrictions on outgoing edges...
+  // for trees, maybe we do; at least for binary trees vs. trees with no restrictions on outgoing
+  // edges...
   public <N1 extends N, E1 extends E> MutableCTreeNetwork<N1, E1> build() {
     NetworkBuilder<Object, Object> graphBuilder =
         NetworkBuilder.directed().allowsSelfLoops(false).allowsParallelEdges(false);

Diff for: jung-io/src/main/java/edu/uci/ics/jung/io/GraphMLReader.java

@@ -701,7 +701,7 @@ protected void createEdge(Attributes atts, TagState state) throws SAXNotSupporte
     }
 
     if (state == TagState.EDGE) {
-      assignEdgeSourceTarget(e, atts, edge_atts); //, id);
+      assignEdgeSourceTarget(e, atts, edge_atts); // , id);
     }
 
     // put remaining attribute/value pairs in edge_data
@@ -711,7 +711,7 @@ protected void createEdge(Attributes atts, TagState state) throws SAXNotSupporte
   }
 
   protected void assignEdgeSourceTarget(
-      E e, Attributes atts, Map<String, String> edge_atts) //, String id)
+      E e, Attributes atts, Map<String, String> edge_atts) // , String id)
       throws SAXNotSupportedException {
     String source_id = edge_atts.remove("source");
     if (source_id == null) {

Diff for: jung-io/src/main/java/edu/uci/ics/jung/io/PajekNetReader.java

@@ -388,7 +388,8 @@ protected E createAddEdge(
     E e = edge_factory.get();
 
     // don't error-check this: let the graph implementation do whatever it's going to do
-    // (add the edge, replace the existing edge, throw an exception--depends on the graph implementation)
+    // (add the edge, replace the existing edge, throw an exception--depends on the graph
+    // implementation)
     g.addEdge(v1, v2, e);
     return e;
   }

Diff for: jung-io/src/main/java/edu/uci/ics/jung/io/graphml/parser/ElementParserRegistry.java

@@ -53,7 +53,8 @@ public ElementParserRegistry(
     parserMap.put(GraphMLConstants.ENDPOINT_NAME, new EndpointElementParser<G, N, E>(context));
     parserMap.put(GraphMLConstants.EDGE_NAME, new EdgeElementParser<G, N, E>(context));
     // TODO: restore this once we have a Hypergraph type again
-    //        parserMap.put(GraphMLConstants.HYPEREDGE_NAME, new HyperEdgeElementParser<G,V,E>(context));
+    //        parserMap.put(GraphMLConstants.HYPEREDGE_NAME, new
+    // HyperEdgeElementParser<G,V,E>(context));
   }
 
   public ElementParser getUnknownElementParser() {

Diff for: jung-io/src/main/java/edu/uci/ics/jung/io/graphml/parser/GraphElementParser.java

@@ -78,7 +78,8 @@ public GraphMetadata parse(XMLEventReader xmlEventReader, StartElement start)
 
       Map<String, N> idToNodeMap = new HashMap<String, N>();
       Collection<EdgeMetadata> edgeMetadata = new LinkedList<EdgeMetadata>();
-      //            Collection<HyperEdgeMetadata> hyperEdgeMetadata = new LinkedList<HyperEdgeMetadata>();
+      //            Collection<HyperEdgeMetadata> hyperEdgeMetadata = new
+      // LinkedList<HyperEdgeMetadata>();
 
       while (xmlEventReader.hasNext()) {
 
@@ -133,7 +134,8 @@ public GraphMetadata parse(XMLEventReader xmlEventReader, StartElement start)
             //                    } else if (GraphMLConstants.HYPEREDGE_NAME.equals(name)) {
             //
             //                        // Parse the edge metadata
-            //                        HyperEdgeMetadata metadata = (HyperEdgeMetadata) getParser(name).parse(
+            //                        HyperEdgeMetadata metadata = (HyperEdgeMetadata)
+            // getParser(name).parse(
             //                                xmlEventReader, element);
             //
             //                        // Create the edge object and store it in the metadata

Diff for: jung-io/src/test/java/edu/uci/ics/jung/io/TestGraphMLWriter.java

@@ -42,7 +42,7 @@ public String apply(Number n) {
         };
 
     Function<String, String> node_name = Function.identity();
-    //TransformerUtils.nopTransformer();
+    // TransformerUtils.nopTransformer();
 
     gmlw.addEdgeData("weight", "integer value for the edge", Integer.toString(-1), edge_weight);
     gmlw.addNodeData("name", "identifier for the node", null, node_name);

Diff for: jung-io/src/test/java/edu/uci/ics/jung/io/graphml/DummyGraphObjectBase.java

@@ -14,14 +14,16 @@ public MutableNetwork<DummyNode, DummyEdge> apply(GraphMetadata arg0) {
       return NetworkBuilder.undirected().allowsParallelEdges(false).allowsSelfLoops(true).build();
     }
   }
-  //    public static class UndirectedSparseGraphFactory implements Function<GraphMetadata, Hypergraph<DummyNode, DummyEdge>> {
+  //    public static class UndirectedSparseGraphFactory implements Function<GraphMetadata,
+  // Hypergraph<DummyNode, DummyEdge>> {
   //
   //        public Hypergraph<DummyNode, DummyEdge> apply(GraphMetadata arg0) {
   //            return new UndirectedSparseGraph<DummyNode, DummyEdge>();
   //        }
   //    }
   //
-  //    public static class SetHypergraphFactory implements Function<GraphMetadata, Hypergraph<DummyNode, DummyEdge>> {
+  //    public static class SetHypergraphFactory implements Function<GraphMetadata,
+  // Hypergraph<DummyNode, DummyEdge>> {
   //
   //        public Hypergraph<DummyNode, DummyEdge> apply(GraphMetadata arg0) {
   //            return new SetHypergraph<DummyNode, DummyEdge>();