camelCase constants. Down with ALL_CAPS!

lib/src/line_splitter.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart_style.src.line_splitter;
 
 import 'dart:math' as math;
 
 import 'chunk.dart';
 import 'debug.dart';
 import 'line_prefix.dart';
 
 /// The number of spaces in a single level of indentation.
-const SPACES_PER_INDENT = 2;
+const spacesPerIndent = 2;
 
 /// The number of indentation levels in a single level of expression nesting.
-const INDENTS_PER_NEST = 2;
+const indentsPerNest = 2;
 
 /// Cost or indent value used to indication no solution could be found.
-const INVALID_SPLITS = -1;
+const invalidSplits = -1;
 
 // TODO(rnystrom): This needs to be updated to take into account how it works
 // now.
 /// Takes a series of [Chunk]s and determines the best way to split them into
 /// lines of output that fit within the page width (if possible).
 ///
 /// Trying all possible combinations is exponential in the number of
 /// [SplitParam]s and expression nesting levels both of which can be quite large
 /// with things like long method chains containing function literals, lots of
 /// named parameters, etc. To tame that, this uses dynamic programming. The
@@ skipping 62 matching lines @@
   /// Convert the line to a [String] representation.
   ///
   /// It will determine how best to split it into multiple lines of output and
   /// return a single string that may contain one or more newline characters.
   void apply(StringBuffer buffer) {
     if (debugFormatter) dumpLine(_chunks, _indent);
 
     var splits = _findBestSplits(new LinePrefix());
 
     // Write each chunk and the split after it.
-    buffer.write(" " * (_indent * SPACES_PER_INDENT));
+    buffer.write(" " * (_indent * spacesPerIndent));
     for (var i = 0; i < _chunks.length - 1; i++) {
       var chunk = _chunks[i];
 
       buffer.write(chunk.text);
 
       if (splits.shouldSplitAt(i)) {
         buffer.write(_lineEnding);
         if (chunk.isDouble) buffer.write(_lineEnding);
 
         var indent = chunk.indent + splits.getNesting(i);
-        buffer.write(" " * (indent * SPACES_PER_INDENT));
+        buffer.write(" " * (indent * spacesPerIndent));
 
         // Should have a valid set of splits when we get here.
-        assert(indent != INVALID_SPLITS);
+        assert(indent != invalidSplits);
       } else {
         if (chunk.spaceWhenUnsplit) buffer.write(" ");
       }
     }
 
     // Write the final chunk without any trailing newlines.
     buffer.write(_chunks.last.text);
   }
 
   /// Finds the best set of splits to apply to the remainder of the line
   /// following [prefix].
   SplitSet _findBestSplits(LinePrefix prefix) {
     // Use the memoized result if we have it.
     if (_bestSplits.containsKey(prefix)) return _bestSplits[prefix];
 
     var indent = prefix.getNextLineIndent(_chunks, _indent);
 
     var bestSplits;
     var lowestCost;
 
     // If there are no required splits, consider not splitting any of the soft
     // splits (if there are any) as one possible solution.
     if (!_suffixContainsHardSplits(prefix)) {
       var splits = new SplitSet();
       var cost = _evaluateCost(prefix, indent, splits);
 
-      if (cost != INVALID_SPLITS) {
+      if (cost != invalidSplits) {
         bestSplits = splits;
         lowestCost = cost;
 
         // If we fit the whole suffix without any splitting, that's going to be
         // the best solution, so don't bother trying any others.
-        if (cost < Cost.OVERFLOW_CHAR) {
+        if (cost < Cost.overflowChar) {
           _bestSplits[prefix] = bestSplits;
           return bestSplits;
         }
       }
     }
 
     // For each split in the suffix, calculate the best cost where that is the
     // first split applied. This recurses so that for each split, we consider
     // all of the possible sets of splits *after* it and determine the best
     // cost subset out of all of those.
     var skippedParams = new Set();
 
-    var length = indent * SPACES_PER_INDENT;
+    var length = indent * spacesPerIndent;
 
     // Don't consider the last chunk, since there's no point in splitting on it.
     for (var i = prefix.length; i < _chunks.length - 1; i++) {
       var split = _chunks[i];
 
       // We must skip over this chunk if it cannot be split.
       if (_canSplit(prefix, split, skippedParams)) {
         var splitParams = _getSplitParams(prefix, i, split);
 
         // Find all the params we did *not* split in the prefix that appear in
@@ skipping 16 matching lines @@
 
           // If it wasn't possible to split the suffix given this nesting stack,
           // skip it.
           if (remaining == null) continue;
 
           var splits = remaining.add(i, longerPrefix.nestingIndent);
           var cost = _evaluateCost(prefix, indent, splits);
 
           // If the suffix is invalid (because of a mis-matching multisplit),
           // skip it.
-          if (cost == INVALID_SPLITS) continue;
+          if (cost == invalidSplits) continue;
 
           if (lowestCost == null ||
               cost < lowestCost ||
               (cost == lowestCost && splits.weight > bestSplits.weight)) {
             lowestCost = cost;
             bestSplits = splits;
           }
         }
       }
 
       // If we go past the end of the page and we've already found a solution
       // that fits, then no other solution that involves overflowing will beat
       // that, so stop.
       length += split.text.length;
       if (split.spaceWhenUnsplit) length++;
       if (length > _pageWidth &&
           lowestCost != null &&
-          lowestCost < Cost.OVERFLOW_CHAR) {
+          lowestCost < Cost.overflowChar) {
         break;
       }
 
       // If we can't leave this split unsplit (because it's hard or has a
       // param that the prefix already forced to split), then stop.
       if (split.isHardSplit) break;
       if (prefix.splitParams.contains(split.param)) break;
 
       skippedParams.add(split.param);
     }
@@ skipping 93 matching lines @@
   }
 
   /// Evaluates the cost (i.e. the relative "badness") of splitting the line
   /// into [lines] physical lines based on the current set of params.
   int _evaluateCost(LinePrefix prefix, int indent, SplitSet splits) {
     assert(splits != null);
 
     // Calculate the length of each line and apply the cost of any spans that
     // get split.
     var cost = 0;
-    var length = indent * SPACES_PER_INDENT;
+    var length = indent * spacesPerIndent;
 
     var params = new Set();
 
     var splitIndexes = [];
 
     endLine() {
       // Punish lines that went over the length. We don't rule these out
       // completely because it may be that the only solution still goes over
       // (for example with long string literals).
       if (length > _pageWidth) {
-        cost += (length - _pageWidth) * Cost.OVERFLOW_CHAR;
+        cost += (length - _pageWidth) * Cost.overflowChar;
       }
     }
 
     for (var i = prefix.length; i < _chunks.length; i++) {
       var chunk = _chunks[i];
 
       length += chunk.text.length;
 
       if (i < _chunks.length - 1) {
         if (splits.shouldSplitAt(i)) {
           endLine();
           splitIndexes.add(i);
 
           if (chunk.param != null && !params.contains(chunk.param)) {
             // Don't double-count params if multiple splits share the same
             // param.
             // TODO(rnystrom): Is this needed? Can we actually let splits that
             // share a param accumulate cost?
             params.add(chunk.param);
             cost += chunk.param.cost;
           }
 
           // Start the new line.
-          length = (chunk.indent + splits.getNesting(i)) * SPACES_PER_INDENT;
+          length = (chunk.indent + splits.getNesting(i)) * spacesPerIndent;
         } else {
           if (chunk.spaceWhenUnsplit) length++;
         }
       }
     }
 
     // See which spans got split. We avoid iterators here for performance.
     for (var i = 0; i < _spans.length; i++) {
       var span = _spans[i];
       for (var j = 0; j < splitIndexes.length; j++) {
@@ skipping 75 matching lines @@
     var result = [];
     for (var i = 0; i < _splitNesting.length; i++) {
       if (_splitNesting[i] != null) {
         result.add("$i:${_splitNesting[i]}");
       }
     }
 
     return result.join(" ");
   }
 }