fix formatting

.eslintrc.js

@@ -9,5 +9,7 @@ module.exports = {
         "sourceType": "module"
     },
     "rules": {
+        "curly": "warn",
+        "brace-style": ["warn", "1tbs"]
     }
 };

package.json

@@ -33,7 +33,7 @@
       "pretest": "npm run build",
       "test": "vows --nocolor; echo",
       "clean": "rm -rf node_modules",
-      "prettier": "prettier --single-quote --write '{src,test}/**/*.js'",
+      "prettier": "prettier --write '{src,test}/**/*.js'",
       "docs": "jsdoc -c jsdoc.config.json",
       "check": "jshint src/*.js"
    },
@@ -69,5 +69,8 @@
        "globals": {
            "console": false
        }
+   },
+   "prettier": {
+       "singleQuote": true
    }
 }

src/adjacent_exchange.js

@@ -18,7 +18,9 @@ function count_in_crossings(graph, v, w, inv) {
   for (let iw = 0; iw < w_edges.length; iw++) {
     const p0 = inv[w_edges[iw].target.index];
     for (let iv = 0; iv < v_edges.length; iv++) {
-      if (inv[v_edges[iv].target.index] > p0) cross++;
+      if (inv[v_edges[iv].target.index] > p0) {
+        cross++;
+      }
     }
   }
   return cross;
@@ -32,7 +34,9 @@ function count_out_crossings(graph, v, w, inv) {
   for (let iw = 0; iw < w_edges.length; iw++) {
     const p0 = inv[w_edges[iw].source.index];
     for (let iv = 0; iv < v_edges.length; iv++) {
-      if (inv[v_edges[iv].source.index] > p0) cross++;
+      if (inv[v_edges[iv].source.index] > p0) {
+        cross++;
+      }
     }
   }
   return cross;

src/all_pairs_distance.js

@@ -12,10 +12,13 @@ import { inverse_permutation } from './permutation';
  */
 export function all_pairs_distance(graph, comps) {
   const distances = [];
-  if (!comps) comps = graph.components();
+  if (!comps) {
+    comps = graph.components();
+  }
 
-  for (let i = 0; i < comps.length; i++)
+  for (let i = 0; i < comps.length; i++) {
     distances.push(all_pairs_distance_floyd_warshall(graph, comps[i]));
+  }
   return distances;
 }
 
@@ -35,11 +38,17 @@ export function all_pairs_distance_floyd_warshall(graph, comp) {
 
   const inv = inverse_permutation(comp);
 
-  for (let i = 0; i < comp.length; i++) dist[i][i] = 0;
+  for (let i = 0; i < comp.length; i++) {
+    dist[i][i] = 0;
+  }
 
   const build_dist = (e) => {
-    if (e.source == e.target) return;
-    if (!(e.source.index in inv) || !(e.target.index in inv)) return; // ignore edges outside of comp
+    if (e.source == e.target) {
+      return;
+    }
+    if (!(e.source.index in inv) || !(e.target.index in inv)) {
+      return;
+    } // ignore edges outside of comp
     const u = inv[e.source.index];
     const v = inv[e.target.index];
     dist[v][u] = dist[u][v] = graph.distance(e.index);
@@ -49,14 +58,16 @@ export function all_pairs_distance_floyd_warshall(graph, comp) {
   }
 
   for (let k = 0; k < comp.length; k++) {
-    for (let i = 0; i < comp.length; i++)
+    for (let i = 0; i < comp.length; i++) {
       if (dist[i][k] != Infinity) {
-        for (let j = 0; j < comp.length; j++)
+        for (let j = 0; j < comp.length; j++) {
           if (dist[k][j] != Infinity && dist[i][j] > dist[i][k] + dist[k][j]) {
             dist[i][j] = dist[i][k] + dist[k][j];
             dist[j][i] = dist[i][j];
           }
+        }
       }
+    }
   }
   return dist;
 }
@@ -74,7 +85,9 @@ export function all_pairs_distance_floyd_warshall(graph, comp) {
  */
 
 export function floyd_warshall_with_path(graph, comp) {
-  if (!comp) comp = graph.components()[0];
+  if (!comp) {
+    comp = graph.components()[0];
+  }
 
   const dist = infinities(comp.length, comp.length);
   const next = Array(comp.length);
@@ -92,7 +105,9 @@ export function floyd_warshall_with_path(graph, comp) {
   }
 
   const build_dist = (e) => {
-    if (e.source == e.target) return;
+    if (e.source == e.target) {
+      return;
+    }
     const u = inv[e.source.index];
     const v = inv[e.target.index];
     dist[u][v] = graph.distance(e);

src/bandwidth.js

@@ -2,7 +2,9 @@ import { range } from './range';
 import { inverse_permutation } from './permutation';
 
 export function bandwidth(graph, order) {
-  if (!order) order = range(graph.nodes().length);
+  if (!order) {
+    order = range(graph.nodes().length);
+  }
 
   const inv = inverse_permutation(order);
   const links = graph.links();

src/barycenter_order.js

@@ -20,17 +20,28 @@ export function barycenter_order(graph, comps, max_iter) {
 // P. Eades and N. Wormald, Edge crossings in drawings of bipartite graphs.
 // Algorithmica, vol. 11 (1994) 379–403.
 function median(neighbors) {
-  if (neighbors.length === 0) return -1; // should not happen
-  if (neighbors.length === 1) return neighbors[0];
-  if (neighbors.length === 2) return (neighbors[0] + neighbors[1]) / 2;
+  if (neighbors.length === 0) {
+    return -1;
+  } // should not happen
+  if (neighbors.length === 1) {
+    return neighbors[0];
+  }
+  if (neighbors.length === 2) {
+    return (neighbors[0] + neighbors[1]) / 2;
+  }
   neighbors.sort(cmp_number);
-  if (neighbors.length % 2) return neighbors[(neighbors.length - 1) / 2];
+  if (neighbors.length % 2) {
+    return neighbors[(neighbors.length - 1) / 2];
+  }
   const rm = neighbors.length / 2;
   const lm = rm - 1;
   const rspan = neighbors[neighbors.length - 1] - neighbors[rm];
   const lspan = neighbors[lm] - neighbors[0];
-  if (lspan == rspan) return (neighbors[lm] + neighbors[rm]) / 2;
-  else return (neighbors[lm] * rspan + neighbors[rm] * lspan) / (lspan + rspan);
+  if (lspan == rspan) {
+    return (neighbors[lm] + neighbors[rm]) / 2;
+  } else {
+    return (neighbors[lm] * rspan + neighbors[rm] * lspan) / (lspan + rspan);
+  }
 }
 
 export function barycenter(graph, comp, max_iter) {
@@ -47,8 +58,11 @@ export function barycenter(graph, comp, max_iter) {
     return [layer1, layer2, count_crossings(graph, layer1, layer2)];
   }
 
-  if (!max_iter) max_iter = 24;
-  else if (max_iter % 2 == 1) max_iter++; // want even number of iterations
+  if (!max_iter) {
+    max_iter = 24;
+  } else if (max_iter % 2 == 1) {
+    max_iter++;
+  } // want even number of iterations
 
   let inv_layer = inverse_permutation(layer2);
 
@@ -69,8 +83,11 @@ export function barycenter(graph, comp, max_iter) {
       // degree vertex
       d = (graph.edges(b).length % 2) - (graph.edges(a).length % 2);
     }
-    if (d < 0) return -1;
-    else if (d > 0) return 1;
+    if (d < 0) {
+      return -1;
+    } else if (d > 0) {
+      return 1;
+    }
     return 0;
   };
 
@@ -84,14 +101,18 @@ export function barycenter(graph, comp, max_iter) {
       // Compute the median/barycenter for this node and set
       // its (real) value into node.pos
       v = nodes[layer[i]];
-      if (layer == layer1) neighbors = graph.outEdges(v.index);
-      else neighbors = graph.inEdges(v.index);
+      if (layer == layer1) {
+        neighbors = graph.outEdges(v.index);
+      } else {
+        neighbors = graph.inEdges(v.index);
+      }
       neighbors = neighbors.map(inv_neighbor);
       med[v.index] = +median(neighbors);
     }
     layer.sort(barycenter_sort);
-    for (let i = 0; i < layer.length; i++)
+    for (let i = 0; i < layer.length; i++) {
       inv_layer = inverse_permutation(layer);
+    }
     crossings = count_crossings(graph, layer1, layer2);
     if (crossings < best_crossings) {
       best_crossings = crossings;

src/bfs.js

@@ -28,13 +28,17 @@ export function bfs_distances(graph, v) {
   const dist = {};
   dist[v] = 0;
   bfs(graph, v, (v, c) => {
-    if (c >= 0 && v != c) dist[c] = dist[v] + 1;
+    if (c >= 0 && v != c) {
+      dist[c] = dist[v] + 1;
+    }
   });
   return dist;
 }
 
 export function all_pairs_distance_bfs(graph, comps) {
-  if (!comps) comps = [graph.nodes_indices()];
+  if (!comps) {
+    comps = [graph.nodes_indices()];
+  }
   const nodes = comps.reduce(flatten).sort(cmp_number);
   const mat = Array(nodes.length);
 

src/bfs_order.js

@@ -2,14 +2,18 @@ import { bfs } from './bfs';
 
 /*jshint loopfunc:true */
 export const bfs_order = (graph, comps) => {
-  if (!comps) comps = graph.components();
+  if (!comps) {
+    comps = graph.components();
+  }
 
   const order = [];
 
   for (let i = 0; i < comps.length; i++) {
     const comp = comps[i];
     bfs(graph, comp[0], (v, c) => {
-      if (c >= 0 && v != c) order.push(v);
+      if (c >= 0 && v != c) {
+        order.push(v);
+      }
     });
   }