Clean up the old memoizer (#1854)

* Remove memoizer from dartdoc (never wound up being viable) and clean up grind so it depends on less

* Restore relevant parts of model_utils_test

Author: jcollins-g

lib/src/dartdoc_options.dart

@@ -20,6 +20,7 @@ import 'dart:io';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:args/args.dart';
 import 'package:dartdoc/dartdoc.dart';
+import 'package:dartdoc/src/io_utils.dart';
 import 'package:dartdoc/src/tuple.dart';
 import 'package:path/path.dart' as pathLib;
 import 'package:yaml/yaml.dart';
@@ -39,21 +40,6 @@ final Directory directoryCurrent = Directory.current;
 final String directoryCurrentPath =
     pathLib.canonicalize(Directory.current.path);
 
-String resolveTildePath(String originalPath) {
-  if (originalPath == null || !originalPath.startsWith('~/')) {
-    return originalPath;
-  }
-
-  String homeDir;
-
-  if (Platform.isWindows) {
-    homeDir = pathLib.absolute(Platform.environment['USERPROFILE']);
-  } else {
-    homeDir = pathLib.absolute(Platform.environment['HOME']);
-  }
-
-  return pathLib.join(homeDir, originalPath.substring(2));
-}
 
 class DartdocOptionError extends DartdocFailure {
   DartdocOptionError(String details) : super(details);

lib/src/io_utils.dart

@@ -12,6 +12,24 @@ import 'dart:io';
 
 import 'package:path/path.dart' as pathLib;
 
+/// Return a resolved path including the home directory in place of tilde
+/// references.
+String resolveTildePath(String originalPath) {
+  if (originalPath == null || !originalPath.startsWith('~/')) {
+    return originalPath;
+  }
+
+  String homeDir;
+
+  if (Platform.isWindows) {
+    homeDir = pathLib.absolute(Platform.environment['USERPROFILE']);
+  } else {
+    homeDir = pathLib.absolute(Platform.environment['HOME']);
+  }
+
+  return pathLib.join(homeDir, originalPath.substring(2));
+}
+
 /// Lists the contents of [dir].
 ///
 /// If [recursive] is `true`, lists subdirectory contents (defaults to `false`).

lib/src/model_utils.dart

@@ -4,18 +4,15 @@
 
 library dartdoc.model_utils;
 
-import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source_io.dart';
-import 'package:collection/collection.dart';
 import 'package:dartdoc/src/model.dart';
 import 'package:path/path.dart' as pathLib;
-import 'package:quiver/core.dart';
 
 final Map<String, String> _fileContents = <String, String>{};
 
@@ -178,195 +175,4 @@ String crossdartifySource(
     newSource = sanitizer.convert(source);
   }
   return newSource;
-}
-
-/// An UnmodifiableListView that computes equality and hashCode based on the
-/// equality and hashCode of its contained objects.
-class _HashableList {
-  final List _source;
-  int _hashCache;
-  _HashableList(this._source);
-
-  @override
-  bool operator ==(other) {
-    if (other is _HashableList) {
-      if (_source.length == other._source.length) {
-        for (var index = 0; index < _source.length; ++index) {
-          if (_source[index] != other._source[index]) return false;
-        }
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @override
-  int get hashCode => _hashCache ??= hashObjects(_source);
-}
-
-/// Like [Memoizer], except in checked mode will validate that the value of the
-/// memoized function is unchanging using [DeepCollectionEquality].  Still
-/// returns the cached value assuming the assertion passes.
-class ValidatingMemoizer extends Memoizer {
-  bool _assert_on_difference = false;
-
-  ValidatingMemoizer() : super() {
-    // Assignment within assert to take advantage of the expression only
-    // being executed in checked mode.
-    assert(_assert_on_difference = true);
-    invalidateMemos();
-  }
-
-  /// In checked mode and when constructed with assert_on_difference == true,
-  /// validate that the return value from f() equals the memoized value.
-  /// Otherwise, a wrapper around putIfAbsent.
-  @override
-  R _cacheIfAbsent<R>(_HashableList key, R Function() f) {
-    if (_assert_on_difference) {
-      if (_memoizationTable.containsKey(key)) {
-        R value = f();
-        if (!new DeepCollectionEquality()
-            .equals(value, _memoizationTable[key])) {
-          throw new AssertionError('${value} != $_memoizationTable[key]');
-        }
-      }
-    }
-    return super._cacheIfAbsent(key, f);
-  }
-}
-
-/// A basic Memoizer class.  Instantiate as a member variable, extend, or use
-/// as a mixin to track object-specific cached values, or instantiate directly
-/// to track other values.
-///
-/// For all methods in this class, the parameter [f] must be a tear-off method
-/// or top level function (not an inline closure) for memoization to work.
-/// [Memoizer] depends on the equality operator on the given function to detect
-/// when we are calling the same function.
-///
-/// Use:
-///
-/// ```dart
-/// String aTestFunction(String greeting, String name) => "${greeting}, ${name}";
-/// int aSlowFunction() { doSome(); return expensiveCalculations(); }
-///
-/// myMemoizer.memoized2(aTestFunction, "Hello, "world");
-/// myMemoizer.memoized(aSlowFunction);
-/// ```
-///
-/// *Not*:
-///
-/// ```dart
-/// String aTestFunction(String greeting, String name) => "${greeting}, ${name}";
-///
-/// myMemoizer.memoized2((a, b) => aTestFunction(a, b), "Hello", "world");
-/// myMemoizer.memoized(() => aSlowFunction());;
-/// ```
-class Memoizer {
-  /// Map of a function and its positional parameters (if any), to a value.
-  final Map<_HashableList, dynamic> _memoizationTable = new HashMap();
-
-  /// Reset the memoization table, forcing calls of the underlying functions.
-  void invalidateMemos() {
-    _memoizationTable.clear();
-  }
-
-  /// A wrapper around putIfAbsent, exposed to allow overrides.
-  R _cacheIfAbsent<R>(_HashableList key, R Function() f) {
-    return _memoizationTable.putIfAbsent(key, f);
-  }
-
-  /// Calls and caches the return value of [f]() if not in the cache, then
-  /// returns the cached value of [f]().
-  R memoized<R>(Function f, {String altKey}) {
-    Object obj = altKey ?? f;
-    _HashableList key = new _HashableList([obj]);
-    return _cacheIfAbsent(key, f);
-  }
-
-  /// Calls and caches the return value of [f]([param1]) if not in the cache, then
-  /// returns the cached value of [f]([param1]).
-  R memoized1<R, A>(R Function(A) f, A param1) {
-    _HashableList key = new _HashableList([f, param1]);
-    return _cacheIfAbsent(key, () => f(param1));
-  }
-
-  /// Calls and caches the return value of [f]([param1], [param2]) if not in the
-  /// cache, then returns the cached value of [f]([param1], [param2]).
-  R memoized2<R, A, B>(R Function(A, B) f, A param1, B param2) {
-    _HashableList key = new _HashableList([f, param1, param2]);
-    return _cacheIfAbsent(key, () => f(param1, param2));
-  }
-
-  /// Calls and caches the return value of [f]([param1], [param2], [param3]) if
-  /// not in the cache, then returns the cached value of [f]([param1],
-  /// [param2], [param3]).
-  R memoized3<R, A, B, C>(R Function(A, B, C) f, A param1, B param2, C param3) {
-    _HashableList key = new _HashableList([f, param1, param2, param3]);
-    return _cacheIfAbsent(key, () => f(param1, param2, param3));
-  }
-
-  /// Calls and caches the return value of [f]([param1], [param2], [param3],
-  /// [param4]) if not in the cache, then returns the cached value of
-  /// [f]([param1], [param2], [param3], [param4]).
-  R memoized4<R, A, B, C, D>(
-      R Function(A, B, C, D) f, A param1, B param2, C param3, D param4) {
-    _HashableList key = new _HashableList([f, param1, param2, param3, param4]);
-    return _cacheIfAbsent(key, () => f(param1, param2, param3, param4));
-  }
-
-  /// Calls and caches the return value of [f]([param1], [param2], [param3],
-  /// [param4], [param5]) if not in the cache, then returns the cached value of [f](
-  /// [param1], [param2], [param3], [param4], [param5]).
-  R memoized5<R, A, B, C, D, E>(R Function(A, B, C, D, E) f, A param1, B param2,
-      C param3, D param4, E param5) {
-    _HashableList key =
-        new _HashableList([f, param1, param2, param3, param4, param5]);
-    return _cacheIfAbsent(key, () => f(param1, param2, param3, param4, param5));
-  }
-
-  /// Calls and caches the return value of [f]([param1], [param2], [param3],
-  /// [param4], [param5], [param6]) if not in the cache, then returns the cached
-  /// value of [f]([param1], [param2], [param3], [param4], [param5], [param6]).
-  R memoized6<R, A, B, C, D, E, F>(R Function(A, B, C, D, E, F) f, A param1,
-      B param2, C param3, D param4, E param5, F param6) {
-    _HashableList key =
-        new _HashableList([f, param1, param2, param3, param4, param5, param6]);
-    return _cacheIfAbsent(
-        key, () => f(param1, param2, param3, param4, param5, param6));
-  }
-
-  /// Calls and caches the return value of [f]([param1], [param2], [param3],
-  /// [param4], [param5], [param6], [param7]) if not in the cache, then returns
-  /// the cached value of [f]([param1], [param2], [param3], [param4], [param5],
-  /// [param6], [param7]).
-  R memoized7<R, A, B, C, D, E, F, G>(R Function(A, B, C, D, E, F, G) f,
-      A param1, B param2, C param3, D param4, E param5, F param6, G param7) {
-    _HashableList key = new _HashableList(
-        [f, param1, param2, param3, param4, param5, param6, param7]);
-    return _cacheIfAbsent(
-        key, () => f(param1, param2, param3, param4, param5, param6, param7));
-  }
-
-  /// Calls and caches the return value of [f]([param1], [param2], [param3],
-  /// [param4], [param5], [param6], [param7], [param8]) if not in the cache,
-  /// then returns the cached value of [f]([param1], [param2], [param3],
-  /// [param4], [param5], [param6], [param7], [param8]).
-  R memoized8<R, A, B, C, D, E, F, G, H>(
-      R Function(A, B, C, D, E, F, G, H) f,
-      A param1,
-      B param2,
-      C param3,
-      D param4,
-      E param5,
-      F param6,
-      G param7,
-      H param8) {
-    _HashableList key = new _HashableList(
-        [f, param1, param2, param3, param4, param5, param6, param7, param8]);
-    return _cacheIfAbsent(
-        key,
-        () =>
-            f(param1, param2, param3, param4, param5, param6, param7, param8));
-  }
-}
+}