camelCase constants. Down with ALL_CAPS!

lib/src/line_writer.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.source_writer;
 
 import 'dart_formatter.dart';
 import 'chunk.dart';
 import 'debug.dart';
 import 'line_splitter.dart';
@@ skipping 150 matching lines @@
     return _chunks.length;
   }
 
   /// Whether there is pending whitespace that depends on the number of
   /// newlines in the source.
   ///
   /// This is used to avoid calculating the newlines between tokens unless
   /// actually needed since doing so is slow when done between every single
   /// token pair.
   bool get needsToPreserveNewlines =>
-      _pendingWhitespace == Whitespace.ONE_OR_TWO_NEWLINES ||
-      _pendingWhitespace == Whitespace.SPACE_OR_NEWLINE;
+      _pendingWhitespace == Whitespace.oneOrTwoNewlines ||
+      _pendingWhitespace == Whitespace.spaceOrNewline;
 
   /// The number of characters of code that can fit in a single line.
   int get pageWidth => _formatter.pageWidth;
 
   LineWriter(this._formatter, this._buffer) {
     indent(_formatter.indent);
     _beginningIndent = _formatter.indent;
   }
 
   /// Writes [string], the text for a single token, to the output.
@@ skipping 21 matching lines @@
 
   /// Writes a [WhitespaceChunk] of [type].
   void writeWhitespace(Whitespace type) {
     _pendingWhitespace = type;
   }
 
   /// Write a soft split with its own param at [cost].
   ///
   /// If unsplit, it expands to a space if [space] is `true`.
   ///
-  /// If [cost] is omitted, defaults to [Cost.NORMAL]. Returns the new param.
+  /// If [cost] is omitted, defaults to [Cost.normal]. Returns the new param.
   SplitParam writeSplit({int cost, bool space}) {
-    if (cost == null) cost = Cost.NORMAL;
+    if (cost == null) cost = Cost.normal;
 
     var param = new SplitParam(cost);
     _writeSplit(_indent, _nesting, param, spaceWhenUnsplit: space);
 
     // If a split inside a multisplit is chosen, this forces the multisplit too.
     // This ensures that, for example, a split inside a collection literal
     // forces the collection to also go multiline. Since a multisplit's param
     // also implies *its* surrounding multisplit, this will split the whole
     // chain of contained multisplits.
     if (_multisplits.isNotEmpty && _multisplits.last.param != null) {
@@ skipping 18 matching lines @@
     // enforce one before the first comment. Example:
     //
     //     library foo;
     //     // comment
     //
     //     class Bar {}
     //
     // Normally, a blank line is required after `library`, but since there is
     // one after the comment, we don't need one before it. This is mainly so
     // that commented out directives stick with their preceding group.
-    if (_pendingWhitespace == Whitespace.TWO_NEWLINES &&
+    if (_pendingWhitespace == Whitespace.twoNewlines &&
         comments.isNotEmpty &&
         comments.first.linesBefore < 2) {
       if (linesBeforeToken > 1) {
-        _pendingWhitespace = Whitespace.NEWLINE;
+        _pendingWhitespace = Whitespace.newline;
       } else {
         for (var i = 1; i < comments.length; i++) {
           if (comments[i].linesBefore > 1) {
-            _pendingWhitespace = Whitespace.NEWLINE;
+            _pendingWhitespace = Whitespace.newline;
             break;
           }
         }
       }
     }
 
     // Write each comment and the whitespace between them.
     for (var i = 0; i < comments.length; i++) {
       var comment = comments[i];
 
       preserveNewlines(comment.linesBefore);
 
       // Don't emit a space because we'll handle it below. If we emit it here,
       // we may get a trailing space if the comment needs a line before it.
-      if (_pendingWhitespace == Whitespace.SPACE) _pendingWhitespace = null;
+      if (_pendingWhitespace == Whitespace.space) _pendingWhitespace = null;
       _emitPendingWhitespace();
 
       if (comment.linesBefore == 0) {
         // If we're sitting on a split, move the comment before it to adhere it
         // to the preceding text.
         if (_shouldMoveCommentBeforeSplit()) {
           _chunks.last.allowText();
         }
 
         // The comment follows other text, so we need to decide if it gets a
@@ skipping 27 matching lines @@
           linesAfter = 1;
         }
       }
 
       if (linesAfter > 0) _writeHardSplit(nest: true, double: linesAfter > 1);
     }
 
     // If the comment has text following it (aside from a grouping character),
     // it needs a trailing space.
     if (_needsSpaceAfterLastComment(comments, token)) {
-      _pendingWhitespace = Whitespace.SPACE;
+      _pendingWhitespace = Whitespace.space;
     }
 
     preserveNewlines(linesBeforeToken);
   }
 
   /// If the current pending whitespace allows some source discretion, pins
   /// that down given that the source contains [numLines] newlines at that
   /// point.
   void preserveNewlines(int numLines) {
     // If we didn't know how many newlines the user authored between the last
     // token and this one, now we do.
     switch (_pendingWhitespace) {
-      case Whitespace.SPACE_OR_NEWLINE:
+      case Whitespace.spaceOrNewline:
         if (numLines > 0) {
-          _pendingWhitespace = Whitespace.NESTED_NEWLINE;
+          _pendingWhitespace = Whitespace.nestedNewline;
         } else {
-          _pendingWhitespace = Whitespace.SPACE;
+          _pendingWhitespace = Whitespace.space;
         }
         break;
 
-      case Whitespace.ONE_OR_TWO_NEWLINES:
+      case Whitespace.oneOrTwoNewlines:
         if (numLines > 1) {
-          _pendingWhitespace = Whitespace.TWO_NEWLINES;
+          _pendingWhitespace = Whitespace.twoNewlines;
         } else {
-          _pendingWhitespace = Whitespace.NEWLINE;
+          _pendingWhitespace = Whitespace.newline;
         }
         break;
     }
   }
 
   /// Increases indentation of the next line by [levels].
   void indent([int levels = 1]) {
     while (levels-- > 0) _indentStack.add(-1);
   }
 
   /// Decreases indentation of the next line by [levels].
   void unindent([int levels = 1]) {
     while (levels-- > 0) _indentStack.removeLast();
   }
 
   /// Starts a new span with [cost].
   ///
   /// Each call to this needs a later matching call to [endSpan].
-  void startSpan([int cost = Cost.NORMAL]) {
+  void startSpan([int cost = Cost.normal]) {
     _openSpans.add(new Span(_currentChunkIndex, cost));
   }
 
   /// Ends the innermost span.
   void endSpan() {
     var span = _openSpans.removeLast();
     span.close(_currentChunkIndex);
 
     // A span that just covers a single chunk can't be split anyway.
     if (span.start == span.end) return;
@@ skipping 78 matching lines @@
 
   /// Writes the current pending [Whitespace] to the output, if any.
   ///
   /// This should only be called after source lines have been preserved to turn
   /// any ambiguous whitespace into a concrete choice.
   void _emitPendingWhitespace() {
     if (_pendingWhitespace == null) return;
     // Output any pending whitespace first now that we know it won't be
     // trailing.
     switch (_pendingWhitespace) {
-      case Whitespace.SPACE:
+      case Whitespace.space:
         _writeText(" ");
         break;
 
-      case Whitespace.NEWLINE:
+      case Whitespace.newline:
         _writeHardSplit();
         break;
 
-      case Whitespace.NESTED_NEWLINE:
+      case Whitespace.nestedNewline:
         _writeHardSplit(nest: true);
         break;
 
-      case Whitespace.NEWLINE_FLUSH_LEFT:
+      case Whitespace.newlineFlushLeft:
         _writeHardSplit(allowIndent: false);
         break;
 
-      case Whitespace.TWO_NEWLINES:
+      case Whitespace.twoNewlines:
         _writeHardSplit(double: true);
         break;
 
-      case Whitespace.SPACE_OR_NEWLINE:
-      case Whitespace.ONE_OR_TWO_NEWLINES:
+      case Whitespace.spaceOrNewline:
+      case Whitespace.oneOrTwoNewlines:
         // We should have pinned these down before getting here.
         assert(false);
         break;
     }
 
     _pendingWhitespace = null;
   }
 
   /// Returns `true` if the last chunk is a split that should be move after the
   /// comment that is about to be written.
@@ skipping 188 matching lines @@
       if (splitParams.contains(chunk.param)) {
         chunk.harden();
       } else {
         // If the chunk isn't hardened, but implies something that is, we can
         // discard the implication since it is always satisfied now.
         chunk.param.implies.removeWhere(splitParams.contains);
       }
     }
   }
 }