pkg/front_end/lib/src/codegen/tools.dart - sdk.git - Git at Google

 // Copyright (c) 2017, 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.

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

 import 'package:path/path.dart';

 /**
  * Type of functions used to compute the contents of a set of generated files.
  * [pkgPath] is the path to the current package.
  */
 typedef Map<String, FileContentsComputer> DirectoryContentsComputer(
     String pkgPath);

 /**
  * Type of functions used to compute the contents of a generated file.
  * [pkgPath] is the path to the current package.
  */
 typedef Future<String> FileContentsComputer(String pkgPath);

 /**
  * Abstract base class representing behaviors common to generated files and
  * generated directories.
  */
 abstract class GeneratedContent {
   /**
    * Check whether the [output] has the correct contents, and return true if it
    * does.  [pkgPath] is the path to the current package.
    */
   Future<bool> check(String pkgPath);

   /**
    * Replace the [output] with the correct contents.  [pkgPath] is the path to
    * the current package.
    */
   Future<Null> generate(String pkgPath);

   /**
    * Get a [FileSystemEntity] representing the output file or directory.
    * [pkgPath] is the path to the current package.
    */
   FileSystemEntity output(String pkgPath);

   /**
    * Check that all of the [targets] are up to date.  If they are not, print
    * out a message instructing the user to regenerate them, and exit with a
    * nonzero error code.
    *
    * [pkgPath] is the path to the current package.  [generatorRelPath] is the
    * path to a .dart script the user may use to regenerate the targets.
    *
    * To avoid mistakes when run on Windows, [generatorRelPath] always uses
    * POSIX directory separators.
    */
   static Future<Null> checkAll(String pkgPath, String generatorRelPath,
       Iterable<GeneratedContent> targets) async {
     bool generateNeeded = false;
     for (GeneratedContent target in targets) {
       bool ok = await target.check(pkgPath);
       if (!ok) {
         print("${target.output(pkgPath).absolute}"
             " doesn't have expected contents.");
         generateNeeded = true;
       }
     }
     if (generateNeeded) {
       print('Please regenerate using:');
       String executable = Platform.executable;
       String packageRoot = '';
       if (Platform.packageRoot != null) {
         packageRoot = ' --package-root=${Platform.packageRoot}';
       }
       String generateScript =
           join(pkgPath, joinAll(posix.split(generatorRelPath)));
       print('  $executable$packageRoot $generateScript');
       exit(1);
     } else {
       print('All generated files up to date.');
     }
   }

   /**
    * Regenerate all of the [targets].  [pkgPath] is the path to the current
    * package.
    */
   static Future<Null> generateAll(
       String pkgPath, Iterable<GeneratedContent> targets) async {
     print("Generating...");
     for (GeneratedContent target in targets) {
       await target.generate(pkgPath);
     }
   }
 }

 /**
  * Class representing a single output directory (either generated code or
  * generated HTML). No other content should exist in the directory.
  */
 class GeneratedDirectory extends GeneratedContent {
   /**
    * The path to the directory that will have the generated content.
    */
   final String outputDirPath;

   /**
    * Callback function that computes the directory contents.
    */
   final DirectoryContentsComputer directoryContentsComputer;

   GeneratedDirectory(this.outputDirPath, this.directoryContentsComputer);

   @override
   Future<bool> check(String pkgPath) async {
     Directory outputDirectory = output(pkgPath);
     Map<String, FileContentsComputer> map = directoryContentsComputer(pkgPath);
     try {
       for (String file in map.keys) {
         FileContentsComputer fileContentsComputer = map[file];
         String expectedContents = await fileContentsComputer(pkgPath);
         File outputFile = new File(posix.join(outputDirectory.path, file));
         String actualContents = outputFile.readAsStringSync();
         // Normalize Windows line endings to Unix line endings so that the
         // comparison doesn't fail on Windows.
         actualContents = actualContents.replaceAll('\r\n', '\n');
         if (expectedContents != actualContents) {
           return false;
         }
       }
       int nonHiddenFileCount = 0;
       outputDirectory
           .listSync(recursive: false, followLinks: false)
           .forEach((FileSystemEntity fileSystemEntity) {
         if (fileSystemEntity is File &&
             !basename(fileSystemEntity.path).startsWith('.')) {
           nonHiddenFileCount++;
         }
       });
       if (nonHiddenFileCount != map.length) {
         // The number of files generated doesn't match the number we expected to
         // generate.
         return false;
       }
     } catch (e) {
       // There was a problem reading the file (most likely because it didn't
       // exist).  Treat that the same as if the file doesn't have the expected
       // contents.
       return false;
     }
     return true;
   }

   @override
   Future<Null> generate(String pkgPath) async {
     Directory outputDirectory = output(pkgPath);
     try {
       // delete the contents of the directory (and the directory itself)
       outputDirectory.deleteSync(recursive: true);
     } catch (e) {
       // Error caught while trying to delete the directory, this can happen if
       // it didn't yet exist.
     }
     // re-create the empty directory
     outputDirectory.createSync(recursive: true);

     // generate all of the files in the directory
     Map<String, FileContentsComputer> map = directoryContentsComputer(pkgPath);
     for (String file in map.keys) {
       FileContentsComputer fileContentsComputer = map[file];
       File outputFile = new File(posix.join(outputDirectory.path, file));
       print('  ${outputFile.path}');
       String contents = await fileContentsComputer(pkgPath);
       outputFile.writeAsStringSync(contents);
     }
   }

   @override
   Directory output(String pkgPath) =>
       new Directory(join(pkgPath, joinAll(posix.split(outputDirPath))));
 }

 /**
  * Class representing a single output file (either generated code or generated
  * HTML).
  */
 class GeneratedFile extends GeneratedContent {
   /**
    * The output file to which generated output should be written, relative to
    * the "tool/spec" directory.  This filename uses the posix path separator
    * ('/') regardless of the OS.
    */
   final String outputPath;

   /**
    * Callback function which computes the file.
    */
   final FileContentsComputer computeContents;

   GeneratedFile(this.outputPath, this.computeContents);

   bool get isDartFile => outputPath.endsWith('.dart');

   @override
   Future<bool> check(String pkgPath) async {
     File outputFile = output(pkgPath);
     String expectedContents = await computeContents(pkgPath);
     if (isDartFile) {
       expectedContents = DartFormat.formatText(expectedContents);
     }
     try {
       String actualContents = outputFile.readAsStringSync();
       // Normalize Windows line endings to Unix line endings so that the
       // comparison doesn't fail on Windows.
       actualContents = actualContents.replaceAll('\r\n', '\n');
       return expectedContents == actualContents;
     } catch (e) {
       // There was a problem reading the file (most likely because it didn't
       // exist).  Treat that the same as if the file doesn't have the expected
       // contents.
       return false;
     }
   }

   @override
   Future<Null> generate(String pkgPath) async {
     File outputFile = output(pkgPath);
     print('  ${outputFile.path}');
     String contents = await computeContents(pkgPath);
     outputFile.writeAsStringSync(contents);
     if (isDartFile) {
       DartFormat.formatFile(outputFile);
     }
   }

   @override
   File output(String pkgPath) =>
       new File(join(pkgPath, joinAll(posix.split(outputPath))));
 }

 /**
  * A utility class for invoking dartfmt.
  */
 class DartFormat {
   static String get _dartfmtPath {
     String binName = Platform.isWindows ? 'dartfmt.bat' : 'dartfmt';
     for (var loc in [binName, join('dart-sdk', 'bin', binName)]) {
       var candidatePath = join(dirname(Platform.resolvedExecutable), loc);
       if (new File(candidatePath).existsSync()) {
         return candidatePath;
       }
     }
     throw new StateError('Could not find dartfmt executable');
   }

   static void formatFile(File file) {
     ProcessResult result = Process.runSync(_dartfmtPath, ['-w', file.path]);
     if (result.exitCode != 0) throw result.stderr;
   }

   static String formatText(String text) {
     File file = new File(join(Directory.systemTemp.path, 'gen.dart'));
     file.writeAsStringSync(text);
     ProcessResult result = Process.runSync(_dartfmtPath, ['-w', file.path]);
     if (result.exitCode != 0) throw result.stderr;
     return file.readAsStringSync();
   }
 }
	// Copyright (c) 2017, 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.

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

	import 'package:path/path.dart';

	/**
	* Type of functions used to compute the contents of a set of generated files.
	* [pkgPath] is the path to the current package.
	*/
	typedef Map<String, FileContentsComputer> DirectoryContentsComputer(
	String pkgPath);

	/**
	* Type of functions used to compute the contents of a generated file.
	* [pkgPath] is the path to the current package.
	*/
	typedef Future<String> FileContentsComputer(String pkgPath);

	/**
	* Abstract base class representing behaviors common to generated files and
	* generated directories.
	*/
	abstract class GeneratedContent {
	/**
	* Check whether the [output] has the correct contents, and return true if it
	* does. [pkgPath] is the path to the current package.
	*/
	Future<bool> check(String pkgPath);

	/**
	* Replace the [output] with the correct contents. [pkgPath] is the path to
	* the current package.
	*/
	Future<Null> generate(String pkgPath);

	/**
	* Get a [FileSystemEntity] representing the output file or directory.
	* [pkgPath] is the path to the current package.
	*/
	FileSystemEntity output(String pkgPath);

	/**
	* Check that all of the [targets] are up to date. If they are not, print
	* out a message instructing the user to regenerate them, and exit with a
	* nonzero error code.
	*
	* [pkgPath] is the path to the current package. [generatorRelPath] is the
	* path to a .dart script the user may use to regenerate the targets.
	*
	* To avoid mistakes when run on Windows, [generatorRelPath] always uses
	* POSIX directory separators.
	*/
	static Future<Null> checkAll(String pkgPath, String generatorRelPath,
	Iterable<GeneratedContent> targets) async {
	bool generateNeeded = false;
	for (GeneratedContent target in targets) {
	bool ok = await target.check(pkgPath);
	if (!ok) {
	print("${target.output(pkgPath).absolute}"
	" doesn't have expected contents.");
	generateNeeded = true;
	}
	}
	if (generateNeeded) {
	print('Please regenerate using:');
	String executable = Platform.executable;
	String packageRoot = '';
	if (Platform.packageRoot != null) {
	packageRoot = ' --package-root=${Platform.packageRoot}';
	}
	String generateScript =
	join(pkgPath, joinAll(posix.split(generatorRelPath)));
	print(' $executable$packageRoot $generateScript');
	exit(1);
	} else {
	print('All generated files up to date.');
	}
	}

	/**
	* Regenerate all of the [targets]. [pkgPath] is the path to the current
	* package.
	*/
	static Future<Null> generateAll(
	String pkgPath, Iterable<GeneratedContent> targets) async {
	print("Generating...");
	for (GeneratedContent target in targets) {
	await target.generate(pkgPath);
	}
	}
	}

	/**
	* Class representing a single output directory (either generated code or
	* generated HTML). No other content should exist in the directory.
	*/
	class GeneratedDirectory extends GeneratedContent {
	/**
	* The path to the directory that will have the generated content.
	*/
	final String outputDirPath;

	/**
	* Callback function that computes the directory contents.
	*/
	final DirectoryContentsComputer directoryContentsComputer;

	GeneratedDirectory(this.outputDirPath, this.directoryContentsComputer);

	@override
	Future<bool> check(String pkgPath) async {
	Directory outputDirectory = output(pkgPath);
	Map<String, FileContentsComputer> map = directoryContentsComputer(pkgPath);
	try {
	for (String file in map.keys) {
	FileContentsComputer fileContentsComputer = map[file];
	String expectedContents = await fileContentsComputer(pkgPath);
	File outputFile = new File(posix.join(outputDirectory.path, file));
	String actualContents = outputFile.readAsStringSync();
	// Normalize Windows line endings to Unix line endings so that the
	// comparison doesn't fail on Windows.
	actualContents = actualContents.replaceAll('\r\n', '\n');
	if (expectedContents != actualContents) {
	return false;
	}
	}
	int nonHiddenFileCount = 0;
	outputDirectory
	.listSync(recursive: false, followLinks: false)
	.forEach((FileSystemEntity fileSystemEntity) {
	if (fileSystemEntity is File &&
	!basename(fileSystemEntity.path).startsWith('.')) {
	nonHiddenFileCount++;
	}
	});
	if (nonHiddenFileCount != map.length) {
	// The number of files generated doesn't match the number we expected to
	// generate.
	return false;
	}
	} catch (e) {
	// There was a problem reading the file (most likely because it didn't
	// exist). Treat that the same as if the file doesn't have the expected
	// contents.
	return false;
	}
	return true;
	}

	@override
	Future<Null> generate(String pkgPath) async {
	Directory outputDirectory = output(pkgPath);
	try {
	// delete the contents of the directory (and the directory itself)
	outputDirectory.deleteSync(recursive: true);
	} catch (e) {
	// Error caught while trying to delete the directory, this can happen if
	// it didn't yet exist.
	}
	// re-create the empty directory
	outputDirectory.createSync(recursive: true);

	// generate all of the files in the directory
	Map<String, FileContentsComputer> map = directoryContentsComputer(pkgPath);
	for (String file in map.keys) {
	FileContentsComputer fileContentsComputer = map[file];
	File outputFile = new File(posix.join(outputDirectory.path, file));
	print(' ${outputFile.path}');
	String contents = await fileContentsComputer(pkgPath);
	outputFile.writeAsStringSync(contents);
	}
	}

	@override
	Directory output(String pkgPath) =>
	new Directory(join(pkgPath, joinAll(posix.split(outputDirPath))));
	}

	/**
	* Class representing a single output file (either generated code or generated
	* HTML).
	*/
	class GeneratedFile extends GeneratedContent {
	/**
	* The output file to which generated output should be written, relative to
	* the "tool/spec" directory. This filename uses the posix path separator
	* ('/') regardless of the OS.
	*/
	final String outputPath;

	/**
	* Callback function which computes the file.
	*/
	final FileContentsComputer computeContents;

	GeneratedFile(this.outputPath, this.computeContents);

	bool get isDartFile => outputPath.endsWith('.dart');

	@override
	Future<bool> check(String pkgPath) async {
	File outputFile = output(pkgPath);
	String expectedContents = await computeContents(pkgPath);
	if (isDartFile) {
	expectedContents = DartFormat.formatText(expectedContents);
	}
	try {
	String actualContents = outputFile.readAsStringSync();
	// Normalize Windows line endings to Unix line endings so that the
	// comparison doesn't fail on Windows.
	actualContents = actualContents.replaceAll('\r\n', '\n');
	return expectedContents == actualContents;
	} catch (e) {
	// There was a problem reading the file (most likely because it didn't
	// exist). Treat that the same as if the file doesn't have the expected
	// contents.
	return false;
	}
	}

	@override
	Future<Null> generate(String pkgPath) async {
	File outputFile = output(pkgPath);
	print(' ${outputFile.path}');
	String contents = await computeContents(pkgPath);
	outputFile.writeAsStringSync(contents);
	if (isDartFile) {
	DartFormat.formatFile(outputFile);
	}
	}

	@override
	File output(String pkgPath) =>
	new File(join(pkgPath, joinAll(posix.split(outputPath))));
	}

	/**
	* A utility class for invoking dartfmt.
	*/
	class DartFormat {
	static String get _dartfmtPath {
	String binName = Platform.isWindows ? 'dartfmt.bat' : 'dartfmt';
	for (var loc in [binName, join('dart-sdk', 'bin', binName)]) {
	var candidatePath = join(dirname(Platform.resolvedExecutable), loc);
	if (new File(candidatePath).existsSync()) {
	return candidatePath;
	}
	}
	throw new StateError('Could not find dartfmt executable');
	}

	static void formatFile(File file) {
	ProcessResult result = Process.runSync(_dartfmtPath, ['-w', file.path]);
	if (result.exitCode != 0) throw result.stderr;
	}

	static String formatText(String text) {
	File file = new File(join(Directory.systemTemp.path, 'gen.dart'));
	file.writeAsStringSync(text);
	ProcessResult result = Process.runSync(_dartfmtPath, ['-w', file.path]);
	if (result.exitCode != 0) throw result.stderr;
	return file.readAsStringSync();
	}
	}