feat(cache): Move cache out of core, add a CacheRegister

Author: jbdeboer

lib/application.dart

@@ -73,6 +73,7 @@ import 'package:intl/date_symbol_data_local.dart';
 import 'package:di/di.dart';
 import 'package:angular/angular.dart';
 import 'package:angular/perf/module.dart';
+import 'package:angular/cache/module.dart';
 import 'package:angular/core/module_internal.dart';
 import 'package:angular/core/registry.dart';
 import 'package:angular/core_dom/module_internal.dart';
@@ -94,6 +95,7 @@ import 'package:angular/core_dom/static_keys.dart';
  */
 class AngularModule extends Module {
   AngularModule() {
+    install(new CacheModule());
     install(new CoreModule());
     install(new CoreDomModule());
     install(new DirectiveModule());

lib/core/cache.dart renamed to lib/cache/cache.dart

@@ -1,4 +1,4 @@
-part of angular.core_internal;
+part of angular.cache;
 
 class CacheStats {
   final int capacity;
@@ -32,10 +32,15 @@ abstract class Cache<K, V> {
   /**
    * Removes all entries from the cache.
    */
+  @Deprecated('Use clear() instead')
   void removeAll();
   int get capacity;
+  @Deprecated('Use length instead')
   int get size;
   CacheStats stats();
+
+  void clear() => removeAll();
+  int get length => size;
 }
 
 

lib/cache/cache_register.dart

@@ -0,0 +1,64 @@
+part of angular.cache;
+
+class CacheRegisterStats {
+  final String name;
+  int length;
+
+  CacheRegisterStats(this.name);
+}
+
+@Injectable()
+class CacheRegister {
+  Map<String, Map> _caches = {};
+  List<CacheRegisterStats> _stats = null;
+
+  /**
+   * Registers a cache with the CacheRegister.  The [name] is used for in the stats as
+   * well as a key for [clear].
+   */
+  void registerCache(String name, Map cache) {
+    if (_caches.containsKey(name)) {
+      throw "Cache [$name] already registered";
+    }
+    _caches[name] = cache;
+
+    // The stats object needs to be updated.
+    _stats = null;
+
+  }
+
+  /**
+   * A list of caches and their sizes.
+   */
+  List<CacheRegisterStats> get stats {
+    if (_stats == null) {
+      _stats = [];
+      _caches.forEach((k, v) {
+        _stats.add(new CacheRegisterStats(k));
+      });
+    }
+
+    _stats.forEach((CacheRegisterStats stat) {
+      stat.length = _caches[stat.name].length;
+    });
+    return _stats;
+  }
+
+  /**
+   * Clears one or all the caches.  If [name] is omitted, all caches will be cleared.
+   * Otherwise, only the cache named [name] will be cleared.
+   */
+  void clear([String name]) {
+    if (name == null) {
+      _caches.forEach((k, Map v) {
+        v.clear();
+      });
+      return;
+    }
+    var cache = _caches[name];
+    if (cache == null) {
+      return;
+    }
+    _caches[name].clear();
+  }
+}

lib/cache/future_cache.dart

@@ -0,0 +1,13 @@
+part of angular.cache;
+
+class FutureCache<K, V> extends LruCache<K, Future<V>> {
+  FutureCache({int capacity}) : super(capacity: capacity);
+
+  Future<V> put(K key, Future<V> value) {
+    super.put(key, value);
+    value.then((result) {
+      // Replace the old value with a cheaper version.
+      super.put(key, new Future.value(result));
+    });
+  }
+}

lib/cache/module.dart

@@ -0,0 +1,17 @@
+library angular.cache;
+
+import 'dart:collection';
+import 'dart:async';
+
+import 'package:di/di.dart';
+import 'package:angular/core/annotation_src.dart';
+
+part "cache.dart";
+part "cache_register.dart";
+part "future_cache.dart";
+
+class CacheModule extends Module {
+  CacheModule() {
+    bind(CacheRegister);
+  }
+}

lib/core/module.dart

@@ -22,11 +22,15 @@ export "package:angular/change_detection/change_detection.dart" show
     AvgStopwatch,
     FieldGetterFactory;
 
+export "package:angular/cache/module.dart" show
+    Cache,
+    CacheRegister,
+    CacheRegisterStats;
+
 export "package:angular/core_dom/module_internal.dart" show
     Animation,
     AnimationResult,
     BrowserCookies,
-    Cache,
     Compiler,
     CompilerConfig,
     Cookies,

lib/core/module_internal.dart

@@ -24,7 +24,6 @@ import 'package:angular/core/parser/utils.dart';
 import 'package:angular/core/registry.dart';
 import 'package:angular/core/static_keys.dart';
 
-part "cache.dart";
 part "exception_handler.dart";
 part "interpolate.dart";
 part "scope.dart";
@@ -36,7 +35,6 @@ class CoreModule extends Module {
     bind(ScopeDigestTTL);
 
     bind(MetadataExtractor);
-    bind(Cache);
     bind(ExceptionHandler);
     bind(FormatterMap);
     bind(Interpolate);

lib/core_dom/module_internal.dart

@@ -8,6 +8,8 @@ import 'dart:js' as js;
 import 'package:di/di.dart';
 import 'package:perf_api/perf_api.dart';
 
+import 'package:angular/cache/module.dart';
+
 import 'package:angular/core/annotation.dart';
 import 'package:angular/core/annotation_src.dart' show SHADOW_DOM_INJECTOR_NAME;
 import 'package:angular/core/module_internal.dart';

test/_specs.dart

@@ -18,6 +18,7 @@ export 'package:di/dynamic_injector.dart';
 export 'package:angular/angular.dart';
 export 'package:angular/application.dart';
 export 'package:angular/introspection.dart';
+export 'package:angular/cache/module.dart';
 export 'package:angular/core/annotation.dart';
 export 'package:angular/core/registry.dart';
 export 'package:angular/core/module_internal.dart';

test/angular_spec.dart

@@ -94,6 +94,9 @@ main() {
       var ALLOWED_NAMES = [
         "angular.app.AngularModule",
         "angular.app.Application",
+        "angular.cache.Cache",
+        "angular.cache.CacheRegister",
+        "angular.cache.CacheRegisterStats",
         "angular.core.annotation.ShadowRootAware",
         "angular.core.annotation_src.AttachAware",
         "angular.core.annotation_src.Component",
@@ -142,7 +145,6 @@ main() {
         "angular.core.dom_internal.ViewCache",
         "angular.core.dom_internal.ViewFactory",
         "angular.core.dom_internal.ViewPort",
-        "angular.core_internal.CacheStats",
         "angular.core_internal.ExceptionHandler",
         "angular.core_internal.Interpolate",
         "angular.core_internal.RootScope",

test/cache/cache_register_spec.dart

@@ -0,0 +1,49 @@
+library cache_register_spec;
+
+import '../_specs.dart';
+
+main() => describe('CacheRegister', () {
+  it('should clear caches', (CacheRegister register) {
+    var map = {'a': 2};
+    var map2 = {'b': 3};
+    expect(map.length).toEqual(1);
+    expect(map2.length).toEqual(1);
+
+    register.registerCache('a', map);
+    register.registerCache('b', map2);
+    register.clear('a');
+    expect(map.length).toEqual(0);
+    expect(map2.length).toEqual(1);
+
+    map['a'] = 2;
+    register.clear();
+    expect(map.length).toEqual(0);
+    expect(map2.length).toEqual(0);
+
+
+  });
+
+  it('should return stats when empty', (CacheRegister register) {
+    expect(register.stats).toEqual([]);
+  });
+
+  it('should return correct stats', (CacheRegister register) {
+    var map = {'a': 2};
+    var map2 = {'b': 3, 'c': 4};
+    register.registerCache('a', map);
+    register.registerCache('b', map2);
+
+    expect(register.stats.length).toEqual(2);
+    if (register.stats[0].name == 'a') {
+      expect(register.stats[0].length).toEqual(1);
+      expect(register.stats[1].name).toEqual('b');
+      expect(register.stats[1].length).toEqual(2);
+    } else {
+      expect(register.stats[0].name).toEqual('b');
+      expect(register.stats[0].length).toEqual(2);
+      expect(register.stats[1].name).toEqual('a');
+      expect(register.stats[1].length).toEqual(1);
+    }
+
+  });
+});

test/core/cache_spec.dart renamed to test/cache/cache_spec.dart

@@ -0,0 +1,46 @@
+library future_cache_spec;
+
+import 'dart:async';
+import '../_specs.dart';
+
+main() => describe('FutureCache', () {
+  var cache;
+  beforeEach(() {
+    cache = new FutureCache();
+  });
+
+  it('should return the future immediately', async(() {
+    var completer = new Completer();
+    cache.put('a', completer.future);
+    var fromCache = cache.get('a');
+
+    var result;
+    fromCache.then((value) { result = value; });
+    expect(result).toBeNull();
+    // We should get the same future back.
+    expect(fromCache).toBe(completer.future);
+
+    completer.complete(6);
+    microLeap();
+
+    expect(result).toEqual(6);
+  }));
+
+  it('should return a different future after being resolved', async(() {
+    var completer = new Completer();
+    cache.put('a', completer.future);
+    completer.complete(6);
+    microLeap();
+
+    var fromCache = cache.get('a');
+
+    var result;
+    fromCache.then((value) { result = value; });
+    expect(result).toBeNull();
+    // Different future.
+    expect(fromCache).not.toBe(completer.future);
+
+    microLeap();
+    expect(result).toEqual(6);
+  }));
+});