Change the way Patterns work in scheduled_test/descriptor.

pkg/scheduled_test/lib/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.
 
 /// A library for declaratively describing a filesystem structure, usually for
 /// the purpose of creating or validating it as part of a scheduled test.
 ///
 /// You can use [dir] and [file] to define a filesystem structure. Then, you can
 /// call [Entry.create] to schedule a task that will create that structure on
 /// the physical filesystem, or [Entry.validate] to schedule an assertion that
@@ skipping 44 matching lines @@
 ///         currentSchedule.onComplete.schedule(() {
 ///           d.defaultRoot = null;
 ///           return tempDir.delete(recursive: true);
 ///         });
 ///       });
 ///
 ///       // ...
 ///     }
 library descriptor;
 
+import 'dart:core' as core show Pattern;
+import 'dart:core' hide Pattern;
 import 'dart:async';
 
 import '../../../pkg/pathos/lib/path.dart' as path;
 
 import 'scheduled_test.dart';
 import 'src/descriptor/async.dart';
 import 'src/descriptor/directory.dart';
 import 'src/descriptor/entry.dart';
 import 'src/descriptor/file.dart';
 import 'src/descriptor/nothing.dart';
+import 'src/descriptor/pattern.dart';
 
 export 'src/descriptor/async.dart';
 export 'src/descriptor/directory.dart';
 export 'src/descriptor/entry.dart';
 export 'src/descriptor/file.dart';
 export 'src/descriptor/nothing.dart';
+export 'src/descriptor/pattern.dart';
 
 /// The root path for descriptors. Top-level descriptors will be created and
 /// validated at this path. Defaults to the current working directory.
 ///
 /// If this is set to `null`, it will reset itself to the current working
 /// directory.
 String get defaultRoot => _defaultRoot == null ? path.current : _defaultRoot;
 set defaultRoot(String value) {
   _defaultRoot = value;
 }
 String _defaultRoot;
 
 /// Creates a new text [File] descriptor with [name] and [contents].
-File file(Pattern name, [String contents='']) => new File(name, contents);
+File file(String name, [String contents='']) => new File(name, contents);
 
 /// Creates a new binary [File] descriptor with [name] and [contents].
-File binaryFile(Pattern name, List<int> contents) =>
+File binaryFile(String name, List<int> contents) =>
     new File.binary(name, contents);
 
 /// Creates a new [Directory] descriptor with [name] and [contents].
-Directory dir(Pattern name, [Iterable<Entry> contents]) =>
+Directory dir(String name, [Iterable<Entry> contents]) =>
     new Directory(name, contents == null ? <Entry>[] : contents);
 
 /// Creates a new descriptor wrapping a [Future]. This descriptor forwards all
 /// asynchronous operations to the result of [future].
 Async async(Future<Entry> future) => new Async(future);
 
 /// Creates a new [Nothing] descriptor that asserts that no entry named [name]
 /// exists.
-Nothing nothing(Pattern name) => new Nothing(name);
+Nothing nothing(String name) => new Nothing(name);
+
+/// Creates a new [Pattern] descriptor that asserts than an entry with a name
+/// matching [pattern] exists, and matches the [Entry] returned by [fn].
+Pattern pattern(core.Pattern name, EntryCreator fn) => new Pattern(name, fn);

[Bob Nystrom, 2013/03/15 21:58:46]

It's pretty verbose at callsites to always have to do new RegExp(). How about
making the first parameter a string and then automatically wrap it in a RegExp?

[nweiz, 2013/03/15 23:17:21]

I don't like disallowing other Patterns. I think the correct solution here would
be less-verbose RegExps, but given that that's not the Dart Way I don't want to
sacrifice flexibility here.

[Bob Nystrom, 2013/03/18 21:06:34]

I like that Pattern (er, I mean descriptor.Pattern) is flexible and takes a
(dart:core) Pattern. But for the top-level DSL function, I think terseness is
its main job. I think given that, it might make sense for it to implicitly mean
"RegExp".

Another thing I worry about is that currently, it *will* accept a string
(because it implements Pattern), but then it won't do what you expect.

Maybe another option is to have a different top-level method for "regexp pattern
descriptor"?

[nweiz, 2013/03/18 21:41:05]

"new d.PatternDescriptor(..., (name) => d.dir(name, ...))" is exceptionally
verbose compared to "d.dirPattern(..., ...)". Especially given that patterns are
relatively rarely-used anyway, I'd like to make all the uses mostly terse rather
than splitting them into very terse and very verbose.
I'm pretty sure if you pass a String to a method named "pattern", you'll expect
it to behave the same way it would behave when you pass it to any other method
that takes a Pattern. I think this is a feature.
I'd rather not make a combinatorial explosion of method names, and I don't think
"regExpDirPattern(..., ...)" is much better than "dirPattern(new RegExp(...),
...)".

[Bob Nystrom, 2013/03/18 22:05:34]

Ah, forgot about filePattern() and dirPattern(). SGTM!