pkg/scheduled_test/lib/src/descriptor/directory_descriptor.dart

// Copyright (c) 2013, 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 descriptor.directory;

import 'dart:async';
import 'dart:io';

import 'package:path/path.dart' as path;
import 'package:stack_trace/stack_trace.dart';

import '../../descriptor.dart';
import '../../scheduled_test.dart';
import '../utils.dart';

/// A descriptor describing a directory containing multiple files.
class DirectoryDescriptor extends Descriptor implements LoadableDescriptor {
  /// The entries contained within this directory. This is intentionally
  /// mutable.
  final List<Descriptor> contents;

  DirectoryDescriptor(String name, Iterable<Descriptor> contents)
      : super(name),
        contents = contents.toList();

  Future create([String parent]) => schedule(() {
    if (parent == null) parent = defaultRoot;
    var fullPath = path.join(parent, name);
    return Chain.track(new Directory(fullPath).create(recursive: true))
        .then((_) {
      return Future.wait(
          contents.map((entry) => entry.create(fullPath)).toList());
    });
  }, 'creating directory:\n${describe()}');

  Future validate([String parent]) => schedule(() => validateNow(parent),
      'validating directory:\n${describe()}');

  Future validateNow([String parent]) {
    if (parent == null) parent = defaultRoot;
    var fullPath = path.join(parent, name);
    if (!new Directory(fullPath).existsSync()) {
      fail("Directory not found: '$fullPath'.");
    }

    return Future.wait(contents.map((entry) {
      return syncFuture(() => entry.validateNow(fullPath))
          .then((_) => null)
          .catchError((e) => e);
    })).then((results) {
      var errors = results.where((e) => e != null);
      if (errors.isEmpty) return;
      throw _DirectoryValidationError.merge(errors);
    });
  }

  Stream<List<int>> load(String pathToLoad) {
    return futureStream(syncFuture(() {
      if (path.posix.isAbsolute(pathToLoad)) {
        throw new ArgumentError("Can't load absolute path '$pathToLoad'.");
      }

      var split = path.posix.split(path.posix.normalize(pathToLoad));
      if (split.isEmpty || split.first == '.' || split.first == '..') {
        throw new ArgumentError("Can't load '$pathToLoad' from within "
            "'$name'.");
      }

      var requiresReadable = split.length == 1;
      var matchingEntries = contents.where((entry) {
        return entry.name == split.first && (requiresReadable ?
            entry is ReadableDescriptor :
            entry is LoadableDescriptor);
      }).toList();

      var adjective = requiresReadable ? 'readable' : 'loadable';
      if (matchingEntries.length == 0) {
        fail("Couldn't find a $adjective entry named '${split.first}' within "
             "'$name'.");
      } else if (matchingEntries.length > 1) {
        fail("Found multiple $adjective entries named '${split.first}' within "
             "'$name'.");
      } else {
        var remainingPath = split.sublist(1);
        if (remainingPath.isEmpty) {
          return (matchingEntries.first as ReadableDescriptor).read();
        } else {
          return (matchingEntries.first as LoadableDescriptor)
              .load(path.posix.joinAll(remainingPath));
        }
      }
    }));
  }

  String describe() {
    if (contents.isEmpty) return name;

    var buffer = new StringBuffer();
    buffer.writeln(name);
    for (var entry in contents.take(contents.length - 1)) {
      var entryString = prefixLines(entry.describe(), prefix: '|   ')
          .replaceFirst('|   ', '|-- ');
      buffer.writeln(entryString);
    }

    var lastEntryString = prefixLines(contents.last.describe(), prefix: '    ')
        .replaceFirst('    ', "'-- ");
    buffer.write(lastEntryString);
    return buffer.toString();
  }
}

/// A class for formatting errors thrown by [DirectoryDescriptor].
class _DirectoryValidationError {
  final Iterable<String> errors;

  /// Flatten nested [_DirectoryValidationError]s in [errors] to create a single
  /// list of errors.
  static _DirectoryValidationError merge(Iterable errors) {
    return new _DirectoryValidationError(errors.expand((error) {
      if (error is _DirectoryValidationError) return error.errors;
      return [error];
    }));
  }

  _DirectoryValidationError(Iterable errors)
      : errors = errors.map((e) => e.toString()).toList();

  String toString() {
    if (errors.length == 1) return errors.single;
    return errors.map((e) => prefixLines(e, prefix: '  ', firstPrefix: '* '))
        .join('\n');
  }
}