add from option to run

lib/src/mirror_loader.dart

 // Copyright (c) 2015, 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 initialize.mirror_loader;
 
 import 'dart:collection' show Queue;
 import 'dart:mirrors';
 import 'package:path/path.dart' as path;
 import 'package:initialize/initialize.dart';
 
 final _root = currentMirrorSystem().isolate.rootLibrary;
 
 Queue<Function> loadInitializers(
-    {List<Type> typeFilter, InitializerFilter customFilter}) {
-  return new InitializationCrawler(typeFilter, customFilter).run();
+    {List<Type> typeFilter, InitializerFilter customFilter, Uri from}) {
+  return new InitializationCrawler(typeFilter, customFilter, from: from).run();
 }
 
 // Crawls a library and all its dependencies for `Initializer` annotations using
 // mirrors
 class InitializationCrawler {
   // Set of all visited annotations, keys are the declarations that were
   // annotated, values are the annotations that have been processed.
   static final _annotationsFound =
       new Map<DeclarationMirror, Set<InstanceMirror>>();
 
   // If non-null, then only these annotations should be processed.
   final List<Type> typeFilter;
 
   // If non-null, then only annotations which return true when passed to this
   // function will be processed.
   final InitializerFilter customFilter;
 
-  InitializationCrawler(this.typeFilter, this.customFilter);
+  /// Optional property, if supplied then crawling will run from this library
+  /// only.
+  ///
+  /// Note: This is only supported in the mirror_loader.dart. It is not
+  /// supported statically.
+  final LibraryMirror _rootLibrary;
+
+  InitializationCrawler(this.typeFilter, this.customFilter, {Uri from})
+      : _rootLibrary = currentMirrorSystem().libraries[from] {
+    if (from != null && _rootLibrary == null) {
+      throw 'Unable to find library at $from.';
+    }
+  }
 
   // The primary function in this class, invoke it to crawl and collect all the
   // annotations into a queue of init functions.
   Queue<Function> run() {
     var librariesSeen = new Set<LibraryMirror>();
     var queue = new Queue<Function>();
     var libraries = currentMirrorSystem().libraries;
 
-    var trampolineUri = Uri.parse('${_root.uri}\$trampoline');
-    if (libraries.containsKey(trampolineUri)) {
+    if (_rootLibrary != null) {
+      _readLibraryDeclarations(_rootLibrary, librariesSeen, queue);
+    } else if (libraries.containsKey(Uri.parse('${_root.uri}\$trampoline'))) {
       // In dartium, process all relative libraries in reverse order of when
       // they were seen.
       // TODO(jakemac): This is an approximation of what we actually want.
       // https://github.com/dart-lang/initialize/issues/25

[Siggi Cherem (dart-lang), 2015/03/23 20:25:55]

Now that we have `from:`, we can go ahead and delete this portion of the code
and make `initialize` once more independent of Dartium, yay! :)

[jakemac, 2015/03/23 20:58:04]

done, and bumped version to a breaking change

       var relativeLibraryUris = new List.from(libraries.keys
           .where((uri) => uri.scheme != 'package' && uri.scheme != 'dart'));
 
       for (var import in relativeLibraryUris.reversed) {
         // Always load the package: version of a library if available for
         // canonicalization purposes.
         var libToRun;
         if (_isHttpStylePackageUrl(import)) {
           var packageUri = _packageUriFor(import);
           libToRun = libraries[packageUri];
@@ skipping 181 matching lines @@
     return true;
   }
 }
 
 final _TOP_LEVEL_FUNCTIONS_ONLY = new UnsupportedError(
     'Only top level methods are supported for initializers');
 
 final _UNSUPPORTED_DECLARATION = new UnsupportedError(
     'Initializers are only supported on libraries, classes, and top level '
     'methods');