Coverage report for 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.line_writer;

import 'chunk.dart';

import 'dart_formatter.dart';

import 'debug.dart' as debug;

import 'line_splitting/line_splitter.dart';

import 'whitespace.dart';

/// Given a series of chunks, splits them into lines and writes the result to

/// a buffer.

class LineWriter {

  final _buffer = new StringBuffer();

  final List<Chunk> _chunks;

  final String _lineEnding;

  /// The number of characters allowed in a single line.

  final int pageWidth;

  /// The number of characters of additional indentation to apply to each line.

  ///

  /// This is used when formatting blocks to get the output into the right

  /// column based on where the block appears.

  final int _blockIndentation;

  /// The cache of blocks that have already been formatted.

  final Map<_BlockKey, FormatResult> _blockCache;

  /// The offset in [_buffer] where the selection starts in the formatted code.

  ///

  /// This will be `null` if there is no selection or the writer hasn't reached

  /// the beginning of the selection yet.

  int _selectionStart;

  /// The offset in [_buffer] where the selection ends in the formatted code.

  ///

  /// This will be `null` if there is no selection or the writer hasn't reached

  /// the end of the selection yet.

  int _selectionEnd;

  /// The number of characters that have been written to the output.

        _blockIndentation = 0,

  /// Creates a line writer for a block.

      this._blockIndentation, this._blockCache) {

    // There is always a newline after the opening delimiter.

  }

  /// Gets the results of formatting the child block of [chunk] at with

  /// starting [column].

  ///

  /// If that block has already been formatted, reuses the results.

  ///

  /// The column is the column for the delimiters. The contents of the block

  /// are always implicitly one level deeper than that.

  ///

  ///     main() {

  ///       function(() {

  ///         block;

  ///       });

  ///     }

  ///

  /// When we format the anonymous lambda, [column] will be 2, not 4.

    // Use the cached one if we have it.

    if (cached != null) return cached;

    // TODO(rnystrom): Passing in an initial indent here is hacky. The

    // LineWriter ensures all but the first chunk have a block indent, and this

    // handles the first chunk. Do something cleaner.

  }

  /// Takes all of the chunks and divides them into sublists and line splits

  /// each list.

  ///

  /// Since this is linear and line splitting is worse it's good to feed the

  /// line splitter smaller lists of chunks when possible.

      {bool isCompilationUnit: false, bool flushLeft: false}) {

    // Now that we know what hard splits there will be, break the chunks into

    // independently splittable lines.

    var newlines = 0;

    var indent = firstLineIndent;

    var totalCost = 0;

    var start = 0;

      // Get ready for the next line.

    }

          flushLeft: flushLeft);

    }

    // Be a good citizen, end with a newline.

  }

  /// Takes the chunks from [start] to [end] with leading [indent], removes

  /// them, and runs the [LineSplitter] on them.

      {bool flushLeft}) {

    // Write the newlines required by the previous line.

    }

    if (debug.traceLineWriter) {

    }

    // Run the line splitter.

        flushLeft: flushLeft);

    // Write the indentation of the first line.

    if (!flushLeft) {

    }

    // Write each chunk with the appropriate splits between them.

          // This block didn't split (which implies none of the child blocks

          // of that block split either, recursively), so write them all inline.

        } else {

          // Include the formatted block contents.

          // If this block contains one of the selection markers, tell the

          // writer where it ended up in the final output.

          }

          }

        }

      }

        // Don't write trailing whitespace after the last chunk.

      } else {

      }

    }

  }

  /// Writes the block chunks of [chunk] (and any child chunks of them,

  /// recursively) without any splitting.

      // Recurse into the block.

    }

  }

  /// Writes [chunk] to the output and updates the selection if the chunk

  /// contains a selection marker.

    }

    }

  }

}

/// Key type for the formatted block cache.

///

/// To cache formatted blocks, we just need to know which block it is (the

/// index of its parent chunk) and how far it was indented when we formatted it

/// (the starting column).

class _BlockKey {

  /// The index of the chunk in the surrounding chunk list that contains this

  /// block.

  final Chunk chunk;

  /// The absolute zero-based column number where the block starts.

  final int column;

  }

}

/// The result of formatting a series of chunks.

class FormatResult {

  /// The resulting formatted text, including newlines and leading whitespace

  /// to reach the proper column.

  final String text;

  /// The numeric cost of the chosen solution.

  final int cost;

  /// Where in the resulting buffer the selection starting point should appear

  /// if it was contained within this split list of chunks.

  ///

  /// Otherwise, this is `null`.

  final int selectionStart;

  /// Where in the resulting buffer the selection end point should appear if it

  /// was contained within this split list of chunks.

  ///

  /// Otherwise, this is `null`.

  final int selectionEnd;

}