First commit of pkg/observable
diff --git a/.analysis_options b/.analysis_options
new file mode 100644
index 0000000..dbb6342
--- /dev/null
+++ b/.analysis_options
@@ -0,0 +1,49 @@
+analyzer:
+ strong-mode: true
+linter:
+ rules:
+ #- always_declare_return_types
+ #- always_specify_types
+ #- annotate_overrides
+ #- avoid_as
+ - avoid_empty_else
+ - avoid_init_to_null
+ - avoid_return_types_on_setters
+ - await_only_futures
+ - camel_case_types
+ - cancel_subscriptions
+ #- close_sinks
+ #- comment_references
+ - constant_identifier_names
+ - control_flow_in_finally
+ - empty_catches
+ - empty_constructor_bodies
+ - empty_statements
+ - hash_and_equals
+ - implementation_imports
+ - iterable_contains_unrelated_type
+ - library_names
+ - library_prefixes
+ - list_remove_unrelated_type
+ - non_constant_identifier_names
+ - one_member_abstracts
+ - only_throw_errors
+ - overridden_fields
+ - package_api_docs
+ - package_names
+ - package_prefixed_library_names
+ - prefer_is_not_empty
+ #- public_member_api_docs
+ #- slash_for_doc_comments
+ #- sort_constructors_first
+ #- sort_unnamed_constructors_first
+ - super_goes_last
+ - test_types_in_equals
+ - throw_in_finally
+ #- type_annotate_public_apis
+ - type_init_formals
+ #- unawaited_futures
+ - unnecessary_brace_in_string_interp
+ - unnecessary_getters_setters
+ - unrelated_type_equality_checks
+ - valid_regexps
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..96bc6bb
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,8 @@
+# Files and directories created by pub
+.packages
+.pub/
+packages
+pubspec.lock
+
+# Directory created by dartdoc
+doc/api/
diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000..0617765
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,9 @@
+# Names should be added to this file with this pattern:
+#
+# For individuals:
+# Name <email address>
+#
+# For organizations:
+# Organization <fnmatch pattern>
+#
+Google Inc. <*@google.com>
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..6f5e0ea
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,33 @@
+Want to contribute? Great! First, read this page (including the small print at
+the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement](https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things—for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review.
+
+### File headers
+All files in the project must start with the following header.
+
+ // 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.
+
+### The small print
+Contributions made by corporations are covered by a different agreement than the
+one above, the
+[Software Grant and Corporate Contributor License Agreement](https://developers.google.com/open-source/cla/corporate).
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..82e9b52
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,26 @@
+Copyright 2016, the Dart project authors. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of Google Inc. nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/PATENTS b/PATENTS
new file mode 100644
index 0000000..6954196
--- /dev/null
+++ b/PATENTS
@@ -0,0 +1,23 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Dart Project.
+
+Google hereby grants to you a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this
+section) patent license to make, have made, use, offer to sell, sell,
+import, transfer, and otherwise run, modify and propagate the contents
+of this implementation of Dart, where such license applies only to
+those patent claims, both currently owned by Google and acquired in
+the future, licensable by Google that are necessarily infringed by
+this implementation of Dart. This grant does not include claims that
+would be infringed only as a consequence of further modification of
+this implementation. If you or your agent or exclusive licensee
+institute or order or agree to the institution of patent litigation
+against any entity (including a cross-claim or counterclaim in a
+lawsuit) alleging that this implementation of Dart or any code
+incorporated within this implementation of Dart constitutes direct or
+contributory patent infringement, or inducement of patent
+infringement, then any patent rights granted to you under this License
+for this implementation of Dart shall terminate as of the date such
+litigation is filed.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..3965a6f
--- /dev/null
+++ b/README.md
@@ -0,0 +1,5 @@
+Support for marking objects as observable, and getting notifications when those
+objects are mutated.
+
+This library is used to observe changes to observable types. It also
+has helpers to make implementing and using observable objects easy.
diff --git a/lib/observable.dart b/lib/observable.dart
new file mode 100644
index 0000000..ce82061
--- /dev/null
+++ b/lib/observable.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2016, 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 observable;
+
+export 'src/change_record.dart';
+export 'src/list_diff.dart' show ListChangeRecord;
+export 'src/observable.dart';
+export 'src/observable_list.dart';
+export 'src/observable_map.dart';
+export 'src/property_change_record.dart';
+export 'src/to_observable.dart';
diff --git a/lib/src/change_record.dart b/lib/src/change_record.dart
new file mode 100644
index 0000000..b4c4f24
--- /dev/null
+++ b/lib/src/change_record.dart
@@ -0,0 +1,9 @@
+// Copyright (c) 2016, 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 observable.src.change_record;
+
+/// Records a change to an [Observable].
+// TODO(jmesserly): remove this type
+abstract class ChangeRecord {}
diff --git a/lib/src/list_diff.dart b/lib/src/list_diff.dart
new file mode 100644
index 0000000..c16a613
--- /dev/null
+++ b/lib/src/list_diff.dart
@@ -0,0 +1,398 @@
+// Copyright (c) 2016, 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 observable.src.list_diff;
+
+import 'dart:collection' show UnmodifiableListView;
+import 'dart:math' as math;
+
+import 'change_record.dart' show ChangeRecord;
+
+/// A summary of an individual change to a [List].
+///
+/// Each delta represents that at the [index], [removed] sequence of items were
+/// removed, and counting forward from [index], [addedCount] items were added.
+class ListChangeRecord /* TODO(tvolkert): remove */ extends ChangeRecord {
+ /// The list that changed.
+ final List object;
+
+ /// The index of the change.
+ int get index => _index;
+
+ /// The items removed, if any. Otherwise this will be an empty list.
+ List get removed => _unmodifiableRemoved;
+ UnmodifiableListView _unmodifiableRemoved;
+
+ /// Mutable version of [removed], used during the algorithms as they are
+ /// constructing the object.
+ List _removed;
+
+ /// The number of items added.
+ int get addedCount => _addedCount;
+
+ // Note: conceptually these are final, but for convenience we increment it as
+ // we build the object. It will be "frozen" by the time it is returned the the
+ // user.
+ int _index, _addedCount;
+
+ ListChangeRecord._(this.object, this._index, List removed, this._addedCount)
+ : _removed = removed,
+ _unmodifiableRemoved = new UnmodifiableListView(removed);
+
+ factory ListChangeRecord(List object, int index,
+ {List removed, int addedCount}) {
+ if (removed == null) removed = [];
+ if (addedCount == null) addedCount = 0;
+ return new ListChangeRecord._(object, index, removed, addedCount);
+ }
+
+ /// Returns true if the provided [ref] index was changed by this operation.
+ bool indexChanged(int ref) {
+ // If ref is before the index, then it wasn't changed.
+ if (ref < index) return false;
+
+ // If this was a shift operation, anything after index is changed.
+ if (addedCount != removed.length) return true;
+
+ // Otherwise, anything in the update range was changed.
+ return ref < index + addedCount;
+ }
+
+ String toString() => '#<ListChangeRecord index: $index, '
+ 'removed: $removed, addedCount: $addedCount>';
+}
+
+// Note: This function is *based* on the computation of the Levenshtein
+// "edit" distance. The one change is that "updates" are treated as two
+// edits - not one. With List splices, an update is really a delete
+// followed by an add. By retaining this, we optimize for "keeping" the
+// maximum array items in the original array. For example:
+//
+// 'xxxx123' -> '123yyyy'
+//
+// With 1-edit updates, the shortest path would be just to update all seven
+// characters. With 2-edit updates, we delete 4, leave 3, and add 4. This
+// leaves the substring '123' intact.
+List<List<int>> _calcEditDistances(List current, int currentStart,
+ int currentEnd, List old, int oldStart, int oldEnd) {
+ // "Deletion" columns
+ int rowCount = oldEnd - oldStart + 1;
+ int columnCount = currentEnd - currentStart + 1;
+ List<List<int>> distances = new List<List<int>>(rowCount);
+
+ // "Addition" rows. Initialize null column.
+ for (int i = 0; i < rowCount; i++) {
+ distances[i] = new List(columnCount);
+ distances[i][0] = i;
+ }
+
+ // Initialize null row
+ for (int j = 0; j < columnCount; j++) {
+ distances[0][j] = j;
+ }
+
+ for (int i = 1; i < rowCount; i++) {
+ for (int j = 1; j < columnCount; j++) {
+ if (old[oldStart + i - 1] == current[currentStart + j - 1]) {
+ distances[i][j] = distances[i - 1][j - 1];
+ } else {
+ int north = distances[i - 1][j] + 1;
+ int west = distances[i][j - 1] + 1;
+ distances[i][j] = math.min(north, west);
+ }
+ }
+ }
+
+ return distances;
+}
+
+const _kEditLeave = 0;
+const _kEditUpdate = 1;
+const _kEditAdd = 2;
+const _kEditDelete = 3;
+
+// This starts at the final weight, and walks "backward" by finding
+// the minimum previous weight recursively until the origin of the weight
+// matrix.
+List<int> _spliceOperationsFromEditDistances(List<List<int>> distances) {
+ int i = distances.length - 1;
+ int j = distances[0].length - 1;
+ int current = distances[i][j];
+ List<int> edits = <int>[];
+ while (i > 0 || j > 0) {
+ if (i == 0) {
+ edits.add(_kEditAdd);
+ j--;
+ continue;
+ }
+ if (j == 0) {
+ edits.add(_kEditDelete);
+ i--;
+ continue;
+ }
+ int northWest = distances[i - 1][j - 1];
+ int west = distances[i - 1][j];
+ int north = distances[i][j - 1];
+
+ int min = math.min(math.min(west, north), northWest);
+
+ if (min == northWest) {
+ if (northWest == current) {
+ edits.add(_kEditLeave);
+ } else {
+ edits.add(_kEditUpdate);
+ current = northWest;
+ }
+ i--;
+ j--;
+ } else if (min == west) {
+ edits.add(_kEditDelete);
+ i--;
+ current = west;
+ } else {
+ edits.add(_kEditAdd);
+ j--;
+ current = north;
+ }
+ }
+
+ return edits.reversed.toList();
+}
+
+int _sharedPrefix(List arr1, List arr2, int searchLength) {
+ for (int i = 0; i < searchLength; i++) {
+ if (arr1[i] != arr2[i]) {
+ return i;
+ }
+ }
+ return searchLength;
+}
+
+int _sharedSuffix(List arr1, List arr2, int searchLength) {
+ int index1 = arr1.length;
+ int index2 = arr2.length;
+ int count = 0;
+ while (count < searchLength && arr1[--index1] == arr2[--index2]) {
+ count++;
+ }
+ return count;
+}
+
+/// Lacking individual splice mutation information, the minimal set of
+/// splices can be synthesized given the previous state and final state of an
+/// array. The basic approach is to calculate the edit distance matrix and
+/// choose the shortest path through it.
+///
+/// Complexity: O(l * p)
+/// l: The length of the current array
+/// p: The length of the old array
+List<ListChangeRecord> calcSplices(List current, int currentStart,
+ int currentEnd, List old, int oldStart, int oldEnd) {
+ int prefixCount = 0;
+ int suffixCount = 0;
+
+ int minLength = math.min(currentEnd - currentStart, oldEnd - oldStart);
+ if (currentStart == 0 && oldStart == 0) {
+ prefixCount = _sharedPrefix(current, old, minLength);
+ }
+
+ if (currentEnd == current.length && oldEnd == old.length) {
+ suffixCount = _sharedSuffix(current, old, minLength - prefixCount);
+ }
+
+ currentStart += prefixCount;
+ oldStart += prefixCount;
+ currentEnd -= suffixCount;
+ oldEnd -= suffixCount;
+
+ if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0) {
+ return const [];
+ }
+
+ if (currentStart == currentEnd) {
+ ListChangeRecord splice = new ListChangeRecord(current, currentStart);
+ while (oldStart < oldEnd) {
+ splice._removed.add(old[oldStart++]);
+ }
+
+ return [splice];
+ } else if (oldStart == oldEnd) {
+ return [
+ new ListChangeRecord(current, currentStart,
+ addedCount: currentEnd - currentStart)
+ ];
+ }
+
+ List<int> ops = _spliceOperationsFromEditDistances(_calcEditDistances(
+ current, currentStart, currentEnd, old, oldStart, oldEnd));
+
+ ListChangeRecord splice;
+ List<ListChangeRecord> splices = <ListChangeRecord>[];
+ int index = currentStart;
+ int oldIndex = oldStart;
+ for (int i = 0; i < ops.length; i++) {
+ switch (ops[i]) {
+ case _kEditLeave:
+ if (splice != null) {
+ splices.add(splice);
+ splice = null;
+ }
+
+ index++;
+ oldIndex++;
+ break;
+ case _kEditUpdate:
+ if (splice == null) splice = new ListChangeRecord(current, index);
+
+ splice._addedCount++;
+ index++;
+
+ splice._removed.add(old[oldIndex]);
+ oldIndex++;
+ break;
+ case _kEditAdd:
+ if (splice == null) splice = new ListChangeRecord(current, index);
+
+ splice._addedCount++;
+ index++;
+ break;
+ case _kEditDelete:
+ if (splice == null) splice = new ListChangeRecord(current, index);
+
+ splice._removed.add(old[oldIndex]);
+ oldIndex++;
+ break;
+ }
+ }
+
+ if (splice != null) splices.add(splice);
+ return splices;
+}
+
+int _intersect(int start1, int end1, int start2, int end2) =>
+ math.min(end1, end2) - math.max(start1, start2);
+
+void _mergeSplice(List<ListChangeRecord> splices, ListChangeRecord record) {
+ ListChangeRecord splice = new ListChangeRecord(record.object, record.index,
+ removed: record._removed.toList(), addedCount: record.addedCount);
+
+ bool inserted = false;
+ int insertionOffset = 0;
+
+ // I think the way this works is:
+ // - the loop finds where the merge should happen
+ // - it applies the merge in a particular splice
+ // - then continues and updates the subsequent splices with any offset diff.
+ for (int i = 0; i < splices.length; i++) {
+ final ListChangeRecord current = splices[i];
+ current._index += insertionOffset;
+
+ if (inserted) continue;
+
+ int intersectCount = _intersect(
+ splice.index,
+ splice.index + splice.removed.length,
+ current.index,
+ current.index + current.addedCount);
+
+ if (intersectCount >= 0) {
+ // Merge the two splices
+
+ splices.removeAt(i);
+ i--;
+
+ insertionOffset -= current.addedCount - current.removed.length;
+
+ splice._addedCount += current.addedCount - intersectCount;
+ int deleteCount =
+ splice.removed.length + current.removed.length - intersectCount;
+
+ if (splice.addedCount == 0 && deleteCount == 0) {
+ // merged splice is a noop. discard.
+ inserted = true;
+ } else {
+ List removed = current._removed;
+
+ if (splice.index < current.index) {
+ // some prefix of splice.removed is prepended to current.removed.
+ removed.insertAll(
+ 0, splice.removed.getRange(0, current.index - splice.index));
+ }
+
+ if (splice.index + splice.removed.length >
+ current.index + current.addedCount) {
+ // some suffix of splice.removed is appended to current.removed.
+ removed.addAll(splice.removed.getRange(
+ current.index + current.addedCount - splice.index,
+ splice.removed.length));
+ }
+
+ splice._removed = removed;
+ splice._unmodifiableRemoved = current._unmodifiableRemoved;
+ if (current.index < splice.index) {
+ splice._index = current.index;
+ }
+ }
+ } else if (splice.index < current.index) {
+ // Insert splice here.
+
+ inserted = true;
+
+ splices.insert(i, splice);
+ i++;
+
+ int offset = splice.addedCount - splice.removed.length;
+ current._index += offset;
+ insertionOffset += offset;
+ }
+ }
+
+ if (!inserted) splices.add(splice);
+}
+
+List<ListChangeRecord> _createInitialSplices(
+ List<Object> list, List<ListChangeRecord> records) {
+ List<ListChangeRecord> splices = [];
+ for (ListChangeRecord record in records) {
+ _mergeSplice(splices, record);
+ }
+ return splices;
+}
+
+/// We need to summarize change records. Consumers of these records want to
+/// apply the batch sequentially, and ensure that they can find inserted
+/// items by looking at that position in the list. This property does not
+/// hold in our record-as-you-go records. Consider:
+///
+/// var model = toObservable(['a', 'b']);
+/// model.removeAt(1);
+/// model.insertAll(0, ['c', 'd', 'e']);
+/// model.removeRange(1, 3);
+/// model.insert(1, 'f');
+///
+/// Here, we inserted some records and then removed some of them.
+/// If someone processed these records naively, they would "play back" the
+/// insert incorrectly, because those items will be shifted.
+List<ListChangeRecord> projectListSplices(
+ List<Object> list, List<ListChangeRecord> records) {
+ if (records.length <= 1) return records;
+
+ List<ListChangeRecord> splices = <ListChangeRecord>[];
+ for (ListChangeRecord splice in _createInitialSplices(list, records)) {
+ if (splice.addedCount == 1 && splice.removed.length == 1) {
+ if (splice.removed[0] != list[splice.index]) splices.add(splice);
+ continue;
+ }
+
+ splices.addAll(calcSplices(
+ list,
+ splice.index,
+ splice.index + splice.addedCount,
+ splice._removed,
+ 0,
+ splice.removed.length));
+ }
+
+ return splices;
+}
diff --git a/lib/src/observable.dart b/lib/src/observable.dart
new file mode 100644
index 0000000..7d1ec6f
--- /dev/null
+++ b/lib/src/observable.dart
@@ -0,0 +1,106 @@
+// Copyright (c) 2016, 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 observable.src.observable;
+
+import 'dart:async';
+import 'dart:collection' show UnmodifiableListView;
+
+import 'package:meta/meta.dart';
+
+import 'change_record.dart' show ChangeRecord;
+import 'property_change_record.dart' show PropertyChangeRecord;
+
+/// Represents an object with observable properties. This is used by data in
+/// model-view architectures to notify interested parties of [changes] to the
+/// object's properties (fields or getter/setter pairs).
+///
+/// The interface does not require any specific technique to implement
+/// observability. You can implement it in the following ways:
+///
+/// - Deriving from this class via a mixin or base class. When a field,
+/// property, or indexable item is changed, the derived class should call
+/// [notifyPropertyChange]. See that method for an example.
+/// - Implementing this interface and providing your own implementation.
+abstract class Observable {
+ StreamController<List<ChangeRecord>> _changes;
+
+ List<ChangeRecord> _records;
+
+ /// The stream of property change records to this object, delivered
+ /// asynchronously.
+ ///
+ /// [deliverChanges] can be called to force synchronous delivery.
+ Stream<List<ChangeRecord>> get changes {
+ if (_changes == null) {
+ _changes = new StreamController.broadcast(
+ sync: true, onListen: observed, onCancel: unobserved);
+ }
+ return _changes.stream;
+ }
+
+ /// Derived classes may override this method to be called when the [changes]
+ /// are first observed.
+ // TODO(tvolkert): @mustCallSuper (github.com/dart-lang/sdk/issues/27275)
+ @protected
+ void observed() {}
+
+ /// Derived classes may override this method to be called when the [changes]
+ /// are no longer being observed.
+ // TODO(tvolkert): @mustCallSuper (github.com/dart-lang/sdk/issues/27275)
+ @protected
+ void unobserved() {
+ // Free some memory
+ _changes = null;
+ }
+
+ /// True if this object has any observers.
+ bool get hasObservers => _changes != null && _changes.hasListener;
+
+ /// Synchronously deliver pending [changes].
+ ///
+ /// Returns `true` if any records were delivered, otherwise `false`.
+ /// Pending records will be cleared regardless, to keep newly added
+ /// observers from being notified of changes that occurred before
+ /// they started observing.
+ bool deliverChanges() {
+ List<ChangeRecord> records = _records;
+ _records = null;
+ if (hasObservers && records != null) {
+ _changes.add(new UnmodifiableListView<ChangeRecord>(records));
+ return true;
+ }
+ return false;
+ }
+
+ /// Notify that the [field] name of this object has been changed.
+ ///
+ /// The [oldValue] and [newValue] are also recorded. If the two values are
+ /// equal, no change will be recorded.
+ ///
+ /// For convenience this returns [newValue].
+ /*=T*/ notifyPropertyChange/*<T>*/(
+ Symbol field, /*=T*/ oldValue, /*=T*/ newValue) {
+ if (hasObservers && oldValue != newValue) {
+ notifyChange(new PropertyChangeRecord(this, field, oldValue, newValue));
+ }
+ return newValue;
+ }
+
+ /// Notify observers of a change.
+ ///
+ /// This will automatically schedule [deliverChanges].
+ ///
+ /// For most objects [Observable.notifyPropertyChange] is more convenient, but
+ /// collections sometimes deliver other types of changes such as a
+ /// [MapChangeRecord].
+ void notifyChange(ChangeRecord record) {
+ if (!hasObservers) return;
+ if (_records == null) {
+ _records = [];
+ scheduleMicrotask(deliverChanges);
+ }
+ _records.add(record);
+ }
+}
diff --git a/lib/src/observable_list.dart b/lib/src/observable_list.dart
new file mode 100644
index 0000000..16c49f5
--- /dev/null
+++ b/lib/src/observable_list.dart
@@ -0,0 +1,306 @@
+// Copyright (c) 2016, 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 observable.src.observable_list;
+
+import 'dart:async';
+import 'dart:collection' show ListBase, UnmodifiableListView;
+
+import 'list_diff.dart' show ListChangeRecord, projectListSplices, calcSplices;
+import 'observable.dart' show Observable;
+
+/// Represents an observable list of model values. If any items are added,
+/// removed, or replaced, then observers that are listening to [changes]
+/// will be notified.
+class ObservableList<E> extends ListBase<E> with Observable {
+ List<ListChangeRecord> _listRecords;
+
+ StreamController<List<ListChangeRecord>> _listChanges;
+
+ /// The inner [List<E>] with the actual storage.
+ final List<E> _list;
+
+ /// Creates an observable list of the given [length].
+ ///
+ /// If no [length] argument is supplied an extendable list of
+ /// length 0 is created.
+ ///
+ /// If a [length] argument is supplied, a fixed size list of that
+ /// length is created.
+ ObservableList([int length])
+ : _list = length != null ? new List<E>(length) : <E>[];
+
+ /// Creates an observable list of the given [length].
+ ///
+ /// This constructor exists to work around an issue in the VM whereby
+ /// classes that derive from [ObservableList] and mixin other classes
+ /// require a default generative constructor in the super class that
+ /// does not take optional arguments.
+ ObservableList.withLength(int length) : this(length);
+
+ /// Creates an observable list with the elements of [other]. The order in
+ /// the list will be the order provided by the iterator of [other].
+ factory ObservableList.from(Iterable<E> other) =>
+ new ObservableList<E>()..addAll(other);
+
+ /// The stream of summarized list changes, delivered asynchronously.
+ ///
+ /// Each list change record contains information about an individual mutation.
+ /// The records are projected so they can be applied sequentially. For
+ /// example, this set of mutations:
+ ///
+ /// var model = new ObservableList.from(['a', 'b']);
+ /// model.listChanges.listen((records) => records.forEach(print));
+ /// model.removeAt(1);
+ /// model.insertAll(0, ['c', 'd', 'e']);
+ /// model.removeRange(1, 3);
+ /// model.insert(1, 'f');
+ ///
+ /// The change records will be summarized so they can be "played back", using
+ /// the final list positions to figure out which item was added:
+ ///
+ /// #<ListChangeRecord index: 0, removed: [], addedCount: 2>
+ /// #<ListChangeRecord index: 3, removed: [b], addedCount: 0>
+ ///
+ /// [deliverChanges] can be called to force synchronous delivery.
+ Stream<List<ListChangeRecord>> get listChanges {
+ if (_listChanges == null) {
+ // TODO(jmesserly): split observed/unobserved notions?
+ _listChanges = new StreamController.broadcast(
+ sync: true,
+ onCancel: () {
+ _listChanges = null;
+ },
+ );
+ }
+ return _listChanges.stream;
+ }
+
+ bool get hasListObservers => _listChanges != null && _listChanges.hasListener;
+
+ int get length => _list.length;
+
+ set length(int value) {
+ int len = _list.length;
+ if (len == value) return;
+
+ // Produce notifications if needed
+ _notifyChangeLength(len, value);
+ if (hasListObservers) {
+ if (value < len) {
+ _notifyListChange(value, removed: _list.getRange(value, len).toList());
+ } else {
+ _notifyListChange(len, addedCount: value - len);
+ }
+ }
+
+ _list.length = value;
+ }
+
+ E operator [](int index) => _list[index];
+
+ void operator []=(int index, E value) {
+ E oldValue = _list[index];
+ if (hasListObservers && oldValue != value) {
+ _notifyListChange(index, addedCount: 1, removed: [oldValue]);
+ }
+ _list[index] = value;
+ }
+
+ // Forwarders so we can reflect on the properties.
+ bool get isEmpty => super.isEmpty;
+ bool get isNotEmpty => super.isNotEmpty;
+
+ // TODO(jmesserly): should we support first/last/single? They're kind of
+ // dangerous to use in a path because they throw exceptions. Also we'd need
+ // to produce property change notifications which seems to conflict with our
+ // existing list notifications.
+
+ // The following methods are here so that we can provide nice change events.
+
+ void setAll(int index, Iterable<E> iterable) {
+ if (iterable is! List && iterable is! Set) {
+ iterable = iterable.toList();
+ }
+ int length = iterable.length;
+ if (hasListObservers && length > 0) {
+ _notifyListChange(index,
+ addedCount: length, removed: _list.sublist(index, length));
+ }
+ _list.setAll(index, iterable);
+ }
+
+ void add(E value) {
+ int len = _list.length;
+ _notifyChangeLength(len, len + 1);
+ if (hasListObservers) {
+ _notifyListChange(len, addedCount: 1);
+ }
+
+ _list.add(value);
+ }
+
+ void addAll(Iterable<E> iterable) {
+ int len = _list.length;
+ _list.addAll(iterable);
+
+ _notifyChangeLength(len, _list.length);
+
+ int added = _list.length - len;
+ if (hasListObservers && added > 0) {
+ _notifyListChange(len, addedCount: added);
+ }
+ }
+
+ bool remove(Object element) {
+ for (int i = 0; i < this.length; i++) {
+ if (this[i] == element) {
+ removeRange(i, i + 1);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void removeRange(int start, int end) {
+ _rangeCheck(start, end);
+ int rangeLength = end - start;
+ int len = _list.length;
+
+ _notifyChangeLength(len, len - rangeLength);
+ if (hasListObservers && rangeLength > 0) {
+ _notifyListChange(start, removed: _list.getRange(start, end).toList());
+ }
+
+ _list.removeRange(start, end);
+ }
+
+ void insertAll(int index, Iterable<E> iterable) {
+ if (index < 0 || index > length) {
+ throw new RangeError.range(index, 0, length);
+ }
+ // TODO(floitsch): we can probably detect more cases.
+ if (iterable is! List && iterable is! Set) {
+ iterable = iterable.toList();
+ }
+ int insertionLength = iterable.length;
+ // There might be errors after the length change, in which case the list
+ // will end up being modified but the operation not complete. Unless we
+ // always go through a "toList" we can't really avoid that.
+ int len = _list.length;
+ _list.length += insertionLength;
+
+ _list.setRange(index + insertionLength, this.length, this, index);
+ _list.setAll(index, iterable);
+
+ _notifyChangeLength(len, _list.length);
+
+ if (hasListObservers && insertionLength > 0) {
+ _notifyListChange(index, addedCount: insertionLength);
+ }
+ }
+
+ void insert(int index, E element) {
+ if (index < 0 || index > length) {
+ throw new RangeError.range(index, 0, length);
+ }
+ if (index == length) {
+ add(element);
+ return;
+ }
+ // We are modifying the length just below the is-check. Without the check
+ // Array.copy could throw an exception, leaving the list in a bad state
+ // (with a length that has been increased, but without a new element).
+ if (index is! int) throw new ArgumentError(index);
+ _list.length++;
+ _list.setRange(index + 1, length, this, index);
+
+ _notifyChangeLength(_list.length - 1, _list.length);
+ if (hasListObservers) {
+ _notifyListChange(index, addedCount: 1);
+ }
+ _list[index] = element;
+ }
+
+ E removeAt(int index) {
+ E result = this[index];
+ removeRange(index, index + 1);
+ return result;
+ }
+
+ void _rangeCheck(int start, int end) {
+ if (start < 0 || start > this.length) {
+ throw new RangeError.range(start, 0, this.length);
+ }
+ if (end < start || end > this.length) {
+ throw new RangeError.range(end, start, this.length);
+ }
+ }
+
+ void _notifyListChange(int index, {List removed, int addedCount}) {
+ if (!hasListObservers) return;
+ if (_listRecords == null) {
+ _listRecords = [];
+ scheduleMicrotask(deliverListChanges);
+ }
+ _listRecords.add(new ListChangeRecord(this, index,
+ removed: removed, addedCount: addedCount));
+ }
+
+ void _notifyChangeLength(int oldValue, int newValue) {
+ notifyPropertyChange(#length, oldValue, newValue);
+ notifyPropertyChange(#isEmpty, oldValue == 0, newValue == 0);
+ notifyPropertyChange(#isNotEmpty, oldValue != 0, newValue != 0);
+ }
+
+ void discardListChanges() {
+ // Leave _listRecords set so we don't schedule another delivery.
+ if (_listRecords != null) _listRecords = [];
+ }
+
+ bool deliverListChanges() {
+ if (_listRecords == null) return false;
+ List<ListChangeRecord> records = projectListSplices(this, _listRecords);
+ _listRecords = null;
+
+ if (hasListObservers && records.isNotEmpty) {
+ _listChanges.add(new UnmodifiableListView<ListChangeRecord>(records));
+ return true;
+ }
+ return false;
+ }
+
+ /// Calculates the changes to the list, if lacking individual splice mutation
+ /// information.
+ ///
+ /// This is not needed for change records produced by [ObservableList] itself,
+ /// but it can be used if the list instance was replaced by another list.
+ ///
+ /// The minimal set of splices can be synthesized given the previous state and
+ /// final state of a list. The basic approach is to calculate the edit
+ /// distance matrix and choose the shortest path through it.
+ ///
+ /// Complexity is `O(l * p)` where `l` is the length of the current list and
+ /// `p` is the length of the old list.
+ static List<ListChangeRecord> calculateChangeRecords(
+ List<Object> oldValue, List<Object> newValue) =>
+ calcSplices(newValue, 0, newValue.length, oldValue, 0, oldValue.length);
+
+ /// Updates the [previous] list using the [changeRecords]. For added items,
+ /// the [current] list is used to find the current value.
+ static void applyChangeRecords(List<Object> previous, List<Object> current,
+ List<ListChangeRecord> changeRecords) {
+ if (identical(previous, current)) {
+ throw new ArgumentError("can't use same list for previous and current");
+ }
+
+ for (ListChangeRecord change in changeRecords) {
+ int addEnd = change.index + change.addedCount;
+ int removeEnd = change.index + change.removed.length;
+
+ Iterable addedItems = current.getRange(change.index, addEnd);
+ previous.replaceRange(change.index, removeEnd, addedItems);
+ }
+ }
+}
diff --git a/lib/src/observable_map.dart b/lib/src/observable_map.dart
new file mode 100644
index 0000000..23a7f11
--- /dev/null
+++ b/lib/src/observable_map.dart
@@ -0,0 +1,189 @@
+// Copyright (c) 2016, 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 observable.src.observable_map;
+
+import 'dart:collection';
+
+import 'change_record.dart' show ChangeRecord;
+import 'observable.dart' show Observable;
+import 'property_change_record.dart' show PropertyChangeRecord;
+
+// TODO(jmesserly): this needs to be faster. We currently require multiple
+// lookups per key to get the old value.
+// TODO(jmesserly): this doesn't implement the precise interfaces like
+// LinkedHashMap, SplayTreeMap or HashMap. However it can use them for the
+// backing store.
+
+// TODO(jmesserly): should we summarize map changes like we do for list changes?
+class MapChangeRecord<K, V> extends ChangeRecord {
+ // TODO(jmesserly): we could store this more compactly if it matters, with
+ // subtypes for inserted and removed.
+
+ /// The map key that changed.
+ final K key;
+
+ /// The previous value associated with this key.
+ final V oldValue;
+
+ /// The new value associated with this key.
+ final V newValue;
+
+ /// True if this key was inserted.
+ final bool isInsert;
+
+ /// True if this key was removed.
+ final bool isRemove;
+
+ MapChangeRecord(this.key, this.oldValue, this.newValue)
+ : isInsert = false,
+ isRemove = false;
+
+ MapChangeRecord.insert(this.key, this.newValue)
+ : isInsert = true,
+ isRemove = false,
+ oldValue = null;
+
+ MapChangeRecord.remove(this.key, this.oldValue)
+ : isInsert = false,
+ isRemove = true,
+ newValue = null;
+
+ String toString() {
+ var kind = isInsert ? 'insert' : isRemove ? 'remove' : 'set';
+ return '#<MapChangeRecord $kind $key from: $oldValue to: $newValue>';
+ }
+}
+
+/// Represents an observable map of model values. If any items are added,
+/// removed, or replaced, then observers that are listening to [changes]
+/// will be notified.
+class ObservableMap<K, V> extends Observable implements Map<K, V> {
+ final Map<K, V> _map;
+
+ /// Creates an observable map.
+ ObservableMap() : _map = new HashMap<K, V>();
+
+ /// Creates a new observable map using a [LinkedHashMap].
+ ObservableMap.linked() : _map = new LinkedHashMap<K, V>();
+
+ /// Creates a new observable map using a [SplayTreeMap].
+ ObservableMap.sorted() : _map = new SplayTreeMap<K, V>();
+
+ /// Creates an observable map that contains all key value pairs of [other].
+ /// It will attempt to use the same backing map type if the other map is a
+ /// [LinkedHashMap], [SplayTreeMap], or [HashMap]. Otherwise it defaults to
+ /// [HashMap].
+ ///
+ /// Note this will perform a shallow conversion. If you want a deep conversion
+ /// you should use [toObservable].
+ factory ObservableMap.from(Map<K, V> other) {
+ return new ObservableMap<K, V>.createFromType(other)..addAll(other);
+ }
+
+ /// Like [ObservableMap.from], but creates an empty map.
+ factory ObservableMap.createFromType(Map<K, V> other) {
+ ObservableMap<K, V> result;
+ if (other is SplayTreeMap) {
+ result = new ObservableMap<K, V>.sorted();
+ } else if (other is LinkedHashMap) {
+ result = new ObservableMap<K, V>.linked();
+ } else {
+ result = new ObservableMap<K, V>();
+ }
+ return result;
+ }
+
+ Iterable<K> get keys => _map.keys;
+
+ Iterable<V> get values => _map.values;
+
+ int get length => _map.length;
+
+ bool get isEmpty => length == 0;
+
+ bool get isNotEmpty => !isEmpty;
+
+ bool containsValue(Object value) => _map.containsValue(value);
+
+ bool containsKey(Object key) => _map.containsKey(key);
+
+ V operator [](Object key) => _map[key];
+
+ void operator []=(K key, V value) {
+ if (!hasObservers) {
+ _map[key] = value;
+ return;
+ }
+
+ int len = _map.length;
+ V oldValue = _map[key];
+
+ _map[key] = value;
+
+ if (len != _map.length) {
+ notifyPropertyChange(#length, len, _map.length);
+ notifyChange(new MapChangeRecord.insert(key, value));
+ _notifyKeysValuesChanged();
+ } else if (oldValue != value) {
+ notifyChange(new MapChangeRecord(key, oldValue, value));
+ _notifyValuesChanged();
+ }
+ }
+
+ void addAll(Map<K, V> other) {
+ other.forEach((K key, V value) {
+ this[key] = value;
+ });
+ }
+
+ V putIfAbsent(K key, V ifAbsent()) {
+ int len = _map.length;
+ V result = _map.putIfAbsent(key, ifAbsent);
+ if (hasObservers && len != _map.length) {
+ notifyPropertyChange(#length, len, _map.length);
+ notifyChange(new MapChangeRecord.insert(key, result));
+ _notifyKeysValuesChanged();
+ }
+ return result;
+ }
+
+ V remove(Object key) {
+ int len = _map.length;
+ V result = _map.remove(key);
+ if (hasObservers && len != _map.length) {
+ notifyChange(new MapChangeRecord.remove(key, result));
+ notifyPropertyChange(#length, len, _map.length);
+ _notifyKeysValuesChanged();
+ }
+ return result;
+ }
+
+ void clear() {
+ int len = _map.length;
+ if (hasObservers && len > 0) {
+ _map.forEach((key, value) {
+ notifyChange(new MapChangeRecord.remove(key, value));
+ });
+ notifyPropertyChange(#length, len, 0);
+ _notifyKeysValuesChanged();
+ }
+ _map.clear();
+ }
+
+ void forEach(void f(K key, V value)) => _map.forEach(f);
+
+ String toString() => Maps.mapToString(this);
+
+ // Note: we don't really have a reasonable old/new value to use here.
+ // But this should fix "keys" and "values" in templates with minimal overhead.
+ void _notifyKeysValuesChanged() {
+ notifyChange(new PropertyChangeRecord(this, #keys, null, null));
+ _notifyValuesChanged();
+ }
+
+ void _notifyValuesChanged() {
+ notifyChange(new PropertyChangeRecord(this, #values, null, null));
+ }
+}
diff --git a/lib/src/property_change_record.dart b/lib/src/property_change_record.dart
new file mode 100644
index 0000000..a09c196
--- /dev/null
+++ b/lib/src/property_change_record.dart
@@ -0,0 +1,27 @@
+// Copyright (c) 2016, 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 observable.src.property_change_record;
+
+import 'change_record.dart';
+
+/// A change record to a field of an [Observable] object.
+class PropertyChangeRecord<T> extends ChangeRecord {
+ /// The object that changed.
+ final Object object;
+
+ /// The name of the property that changed.
+ final Symbol name;
+
+ /// The previous value of the property.
+ final T oldValue;
+
+ /// The new value of the property.
+ final T newValue;
+
+ PropertyChangeRecord(this.object, this.name, this.oldValue, this.newValue);
+
+ String toString() =>
+ '#<PropertyChangeRecord $name from: $oldValue to: $newValue>';
+}
diff --git a/lib/src/to_observable.dart b/lib/src/to_observable.dart
new file mode 100644
index 0000000..0a0f316
--- /dev/null
+++ b/lib/src/to_observable.dart
@@ -0,0 +1,49 @@
+// Copyright (c) 2016, 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 observable.src.to_observable;
+
+import 'observable.dart' show Observable;
+import 'observable_list.dart' show ObservableList;
+import 'observable_map.dart' show ObservableMap;
+
+/// Converts the [Iterable] or [Map] to an [ObservableList] or [ObservableMap],
+/// respectively. This is a convenience function to make it easier to convert
+/// literals into the corresponding observable collection type.
+///
+/// If [value] is not one of those collection types, or is already [Observable],
+/// it will be returned unmodified.
+///
+/// If [value] is a [Map], the resulting value will use the appropriate kind of
+/// backing map: either [HashMap], [LinkedHashMap], or [SplayTreeMap].
+///
+/// By default this performs a deep conversion, but you can set [deep] to false
+/// for a shallow conversion. This does not handle circular data structures.
+/// If a conversion is peformed, mutations are only observed to the result of
+/// this function. Changing the original collection will not affect it.
+// TODO(jmesserly): ObservableSet?
+toObservable(dynamic value, {bool deep: true}) =>
+ deep ? _toObservableDeep(value) : _toObservableShallow(value);
+
+dynamic _toObservableShallow(dynamic value) {
+ if (value is Observable) return value;
+ if (value is Map) return new ObservableMap.from(value);
+ if (value is Iterable) return new ObservableList.from(value);
+ return value;
+}
+
+dynamic _toObservableDeep(dynamic value) {
+ if (value is Observable) return value;
+ if (value is Map) {
+ var result = new ObservableMap.createFromType(value);
+ value.forEach((k, v) {
+ result[_toObservableDeep(k)] = _toObservableDeep(v);
+ });
+ return result;
+ }
+ if (value is Iterable) {
+ return new ObservableList.from(value.map(_toObservableDeep));
+ }
+ return value;
+}
diff --git a/pubspec.yaml b/pubspec.yaml
new file mode 100644
index 0000000..0bedbf6
--- /dev/null
+++ b/pubspec.yaml
@@ -0,0 +1,9 @@
+name: observable
+version: 0.14.0
+author: Dart Team <misc@dartlang.org>
+description: Support for marking objects as observable
+homepage: https://github.com/dart-lang/observable
+environment:
+ sdk: '>=1.19.0 <2.0.0'
+dev_dependencies:
+ test: '^0.12.0'
diff --git a/test/list_change_test.dart b/test/list_change_test.dart
new file mode 100644
index 0000000..b07c0b8
--- /dev/null
+++ b/test/list_change_test.dart
@@ -0,0 +1,268 @@
+// Copyright (c) 2016, 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 'package:observable/observable.dart';
+import 'package:test/test.dart';
+
+import 'observable_test_utils.dart';
+
+// This file contains code ported from:
+// https://github.com/rafaelw/ChangeSummary/blob/master/tests/test.js
+
+main() => listChangeTests();
+
+// TODO(jmesserly): port or write array fuzzer tests
+listChangeTests() {
+ StreamSubscription sub;
+ var model;
+
+ tearDown(() {
+ sub.cancel();
+ model = null;
+ });
+
+ _delta(i, r, a) => new ListChangeRecord(model, i, removed: r, addedCount: a);
+
+ test('sequential adds', () {
+ model = toObservable([]);
+ model.add(0);
+
+ var summary;
+ sub = model.listChanges.listen((r) => summary = r);
+
+ model.add(1);
+ model.add(2);
+
+ expect(summary, null);
+ return new Future(() => expectChanges(summary, [_delta(1, [], 2)]));
+ });
+
+ test('List Splice Truncate And Expand With Length', () {
+ model = toObservable(['a', 'b', 'c', 'd', 'e']);
+
+ var summary;
+ sub = model.listChanges.listen((r) => summary = r);
+
+ model.length = 2;
+
+ return new Future(() {
+ expectChanges(summary, [
+ _delta(2, ['c', 'd', 'e'], 0)
+ ]);
+ summary = null;
+ model.length = 5;
+ }).then(newMicrotask).then((_) {
+ expectChanges(summary, [_delta(2, [], 3)]);
+ });
+ });
+
+ group('List deltas can be applied', () {
+ applyAndCheckDeltas(model, copy, changes) => changes.then((summary) {
+ // apply deltas to the copy
+ for (var delta in summary) {
+ copy.removeRange(delta.index, delta.index + delta.removed.length);
+ for (int i = delta.addedCount - 1; i >= 0; i--) {
+ copy.insert(delta.index, model[delta.index + i]);
+ }
+ }
+
+ // Note: compare strings for easier debugging.
+ expect('$copy', '$model', reason: 'summary $summary');
+ });
+
+ test('Contained', () {
+ var model = toObservable(['a', 'b']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeAt(1);
+ model.insertAll(0, ['c', 'd', 'e']);
+ model.removeRange(1, 3);
+ model.insert(1, 'f');
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Delete Empty', () {
+ var model = toObservable([1]);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeAt(0);
+ model.insertAll(0, ['a', 'b', 'c']);
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Right Non Overlap', () {
+ var model = toObservable(['a', 'b', 'c', 'd']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeRange(0, 1);
+ model.insert(0, 'e');
+ model.removeRange(2, 3);
+ model.insertAll(2, ['f', 'g']);
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Left Non Overlap', () {
+ var model = toObservable(['a', 'b', 'c', 'd']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeRange(3, 4);
+ model.insertAll(3, ['f', 'g']);
+ model.removeRange(0, 1);
+ model.insert(0, 'e');
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Right Adjacent', () {
+ var model = toObservable(['a', 'b', 'c', 'd']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeRange(1, 2);
+ model.insert(3, 'e');
+ model.removeRange(2, 3);
+ model.insertAll(0, ['f', 'g']);
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Left Adjacent', () {
+ var model = toObservable(['a', 'b', 'c', 'd']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeRange(2, 4);
+ model.insert(2, 'e');
+
+ model.removeAt(1);
+ model.insertAll(1, ['f', 'g']);
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Right Overlap', () {
+ var model = toObservable(['a', 'b', 'c', 'd']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeAt(1);
+ model.insert(1, 'e');
+ model.removeAt(1);
+ model.insertAll(1, ['f', 'g']);
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Left Overlap', () {
+ var model = toObservable(['a', 'b', 'c', 'd']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeAt(2);
+ model.insertAll(2, ['e', 'f', 'g']);
+ // a b [e f g] d
+ model.removeRange(1, 3);
+ model.insertAll(1, ['h', 'i', 'j']);
+ // a [h i j] f g d
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Prefix And Suffix One In', () {
+ var model = toObservable(['a', 'b', 'c', 'd']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.insert(0, 'z');
+ model.add('z');
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Remove First', () {
+ var model = toObservable([16, 15, 15]);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeAt(0);
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Update Remove', () {
+ var model = toObservable(['a', 'b', 'c', 'd']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeAt(2);
+ model.insertAll(2, ['e', 'f', 'g']); // a b [e f g] d
+ model[0] = 'h';
+ model.removeAt(1);
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+
+ test('Remove Mid List', () {
+ var model = toObservable(['a', 'b', 'c', 'd']);
+ var copy = model.toList();
+ var changes = model.listChanges.first;
+
+ model.removeAt(2);
+
+ return applyAndCheckDeltas(model, copy, changes);
+ });
+ });
+
+ group('edit distance', () {
+ assertEditDistance(orig, changes, expectedDist) => changes.then((summary) {
+ var actualDistance = 0;
+ for (var delta in summary) {
+ actualDistance += delta.addedCount + delta.removed.length;
+ }
+
+ expect(actualDistance, expectedDist);
+ });
+
+ test('add items', () {
+ var model = toObservable([]);
+ var changes = model.listChanges.first;
+ model.addAll([1, 2, 3]);
+ return assertEditDistance(model, changes, 3);
+ });
+
+ test('trunacte and add, sharing a contiguous block', () {
+ var model = toObservable(['x', 'x', 'x', 'x', '1', '2', '3']);
+ var changes = model.listChanges.first;
+ model.length = 0;
+ model.addAll(['1', '2', '3', 'y', 'y', 'y', 'y']);
+ return assertEditDistance(model, changes, 8);
+ });
+
+ test('truncate and add, sharing a discontiguous block', () {
+ var model = toObservable(['1', '2', '3', '4', '5']);
+ var changes = model.listChanges.first;
+ model.length = 0;
+ model.addAll(['a', '2', 'y', 'y', '4', '5', 'z', 'z']);
+ return assertEditDistance(model, changes, 7);
+ });
+
+ test('insert at beginning and end', () {
+ var model = toObservable([2, 3, 4]);
+ var changes = model.listChanges.first;
+ model.insert(0, 5);
+ model[2] = 6;
+ model.add(7);
+ return assertEditDistance(model, changes, 4);
+ });
+ });
+}
diff --git a/test/observable_list_test.dart b/test/observable_list_test.dart
new file mode 100644
index 0000000..51f07bf
--- /dev/null
+++ b/test/observable_list_test.dart
@@ -0,0 +1,320 @@
+// Copyright (c) 2016, 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 'package:observable/observable.dart';
+import 'package:test/test.dart';
+
+import 'observable_test_utils.dart';
+
+main() => _runTests();
+
+_runTests() {
+ // TODO(jmesserly): need all standard List API tests.
+
+ StreamSubscription sub, sub2;
+
+ sharedTearDown() {
+ list = null;
+ sub.cancel();
+ if (sub2 != null) {
+ sub2.cancel();
+ sub2 = null;
+ }
+ }
+
+ group('observe length', () {
+ ObservableList list;
+ List<ChangeRecord> changes;
+
+ setUp(() {
+ list = toObservable([1, 2, 3]) as ObservableList;
+ changes = null;
+ sub = list.changes.listen((records) {
+ changes = getPropertyChangeRecords(records, #length);
+ });
+ });
+
+ tearDown(sharedTearDown);
+
+ test('add changes length', () {
+ list.add(4);
+ expect(list, [1, 2, 3, 4]);
+ return new Future(() {
+ expectChanges(changes, [_lengthChange(3, 4)]);
+ });
+ });
+
+ test('removeObject changes length', () {
+ list.remove(2);
+ expect(list, orderedEquals([1, 3]));
+
+ return new Future(() {
+ expectChanges(changes, [_lengthChange(3, 2)]);
+ });
+ });
+
+ test('removeRange changes length', () {
+ list.add(4);
+ list.removeRange(1, 3);
+ expect(list, [1, 4]);
+ return new Future(() {
+ expectChanges(changes, [_lengthChange(3, 4), _lengthChange(4, 2)]);
+ });
+ });
+
+ test('length= changes length', () {
+ list.length = 5;
+ expect(list, [1, 2, 3, null, null]);
+ return new Future(() {
+ expectChanges(changes, [_lengthChange(3, 5)]);
+ });
+ });
+
+ test('[]= does not change length', () {
+ list[2] = 9000;
+ expect(list, [1, 2, 9000]);
+ return new Future(() {
+ expectChanges(changes, null);
+ });
+ });
+
+ test('clear changes length', () {
+ list.clear();
+ expect(list, []);
+ return new Future(() {
+ expectChanges(changes, [_lengthChange(3, 0)]);
+ });
+ });
+ });
+
+ group('observe index', () {
+ List<ListChangeRecord> changes;
+
+ setUp(() {
+ list = toObservable([1, 2, 3]) as ObservableList;
+ changes = null;
+ sub = list.listChanges.listen((List<ListChangeRecord> records) {
+ changes = getListChangeRecords(records, 1);
+ });
+ });
+
+ tearDown(sharedTearDown);
+
+ test('add does not change existing items', () {
+ list.add(4);
+ expect(list, [1, 2, 3, 4]);
+ return new Future(() {
+ expectChanges(changes, []);
+ });
+ });
+
+ test('[]= changes item', () {
+ list[1] = 777;
+ expect(list, [1, 777, 3]);
+ return new Future(() {
+ expectChanges(changes, [
+ _change(1, addedCount: 1, removed: [2])
+ ]);
+ });
+ });
+
+ test('[]= on a different item does not fire change', () {
+ list[2] = 9000;
+ expect(list, [1, 2, 9000]);
+ return new Future(() {
+ expectChanges(changes, []);
+ });
+ });
+
+ test('set multiple times results in one change', () {
+ list[1] = 777;
+ list[1] = 42;
+ expect(list, [1, 42, 3]);
+ return new Future(() {
+ expectChanges(changes, [
+ _change(1, addedCount: 1, removed: [2]),
+ ]);
+ });
+ });
+
+ test('set length without truncating item means no change', () {
+ list.length = 2;
+ expect(list, [1, 2]);
+ return new Future(() {
+ expectChanges(changes, []);
+ });
+ });
+
+ test('truncate removes item', () {
+ list.length = 1;
+ expect(list, [1]);
+ return new Future(() {
+ expectChanges(changes, [
+ _change(1, removed: [2, 3])
+ ]);
+ });
+ });
+
+ test('truncate and add new item', () {
+ list.length = 1;
+ list.add(42);
+ expect(list, [1, 42]);
+ return new Future(() {
+ expectChanges(changes, [
+ _change(1, removed: [2, 3], addedCount: 1)
+ ]);
+ });
+ });
+
+ test('truncate and add same item', () {
+ list.length = 1;
+ list.add(2);
+ expect(list, [1, 2]);
+ return new Future(() {
+ expectChanges(changes, []);
+ });
+ });
+ });
+
+ test('toString', () {
+ var list = toObservable([1, 2, 3]);
+ expect(list.toString(), '[1, 2, 3]');
+ });
+
+ group('change records', () {
+ List<ChangeRecord> propRecords;
+ List<ListChangeRecord> listRecords;
+
+ setUp(() {
+ list = toObservable([1, 2, 3, 1, 3, 4]) as ObservableList;
+ propRecords = null;
+ listRecords = null;
+ sub = list.changes.listen((r) => propRecords = r);
+ sub2 = list.listChanges.listen((r) => listRecords = r);
+ });
+
+ tearDown(sharedTearDown);
+
+ test('read operations', () {
+ expect(list.length, 6);
+ expect(list[0], 1);
+ expect(list.indexOf(4), 5);
+ expect(list.indexOf(1), 0);
+ expect(list.indexOf(1, 1), 3);
+ expect(list.lastIndexOf(1), 3);
+ expect(list.last, 4);
+ var copy = new List<int>();
+ list.forEach((int i) => copy.add(i));
+ expect(copy, orderedEquals([1, 2, 3, 1, 3, 4]));
+ return new Future(() {
+ // no change from read-only operators
+ expectChanges(propRecords, null);
+ expectChanges(listRecords, null);
+ });
+ });
+
+ test('add', () {
+ list.add(5);
+ list.add(6);
+ expect(list, orderedEquals([1, 2, 3, 1, 3, 4, 5, 6]));
+
+ return new Future(() {
+ expectChanges(propRecords, [
+ _lengthChange(6, 7),
+ _lengthChange(7, 8),
+ ]);
+ expectChanges(listRecords, [_change(6, addedCount: 2)]);
+ });
+ });
+
+ test('[]=', () {
+ list[1] = list.last;
+ expect(list, orderedEquals([1, 4, 3, 1, 3, 4]));
+
+ return new Future(() {
+ expectChanges(propRecords, null);
+ expectChanges(listRecords, [
+ _change(1, addedCount: 1, removed: [2])
+ ]);
+ });
+ });
+
+ test('removeLast', () {
+ expect(list.removeLast(), 4);
+ expect(list, orderedEquals([1, 2, 3, 1, 3]));
+
+ return new Future(() {
+ expectChanges(propRecords, [_lengthChange(6, 5)]);
+ expectChanges(listRecords, [
+ _change(5, removed: [4])
+ ]);
+ });
+ });
+
+ test('removeRange', () {
+ list.removeRange(1, 4);
+ expect(list, orderedEquals([1, 3, 4]));
+
+ return new Future(() {
+ expectChanges(propRecords, [_lengthChange(6, 3)]);
+ expectChanges(listRecords, [
+ _change(1, removed: [2, 3, 1])
+ ]);
+ });
+ });
+
+ test('sort', () {
+ list.sort((x, y) => x - y);
+ expect(list, orderedEquals([1, 1, 2, 3, 3, 4]));
+
+ return new Future(() {
+ expectChanges(propRecords, null);
+ expectChanges(listRecords, [
+ _change(1, addedCount: 1),
+ _change(4, removed: [1])
+ ]);
+ });
+ });
+
+ test('sort of 2 elements', () {
+ var list = toObservable([3, 1]);
+ // Dummy listener to record changes.
+ // TODO(jmesserly): should we just record changes always, to support the sync api?
+ sub = list.listChanges.listen((List<ListChangeRecord> records) => null)
+ as StreamSubscription;
+ list.sort();
+ expect(list.deliverListChanges(), true);
+ list.sort();
+ expect(list.deliverListChanges(), false);
+ list.sort();
+ expect(list.deliverListChanges(), false);
+ });
+
+ test('clear', () {
+ list.clear();
+ expect(list, []);
+
+ return new Future(() {
+ expectChanges(propRecords, [
+ _lengthChange(6, 0),
+ new PropertyChangeRecord(list, #isEmpty, false, true),
+ new PropertyChangeRecord(list, #isNotEmpty, true, false),
+ ]);
+ expectChanges(listRecords, [
+ _change(0, removed: [1, 2, 3, 1, 3, 4])
+ ]);
+ });
+ });
+ });
+}
+
+ObservableList list;
+
+_lengthChange(int oldValue, int newValue) =>
+ new PropertyChangeRecord(list, #length, oldValue, newValue);
+
+_change(int index, {List removed: const [], int addedCount: 0}) =>
+ new ListChangeRecord(list, index, removed: removed, addedCount: addedCount);
diff --git a/test/observable_map_test.dart b/test/observable_map_test.dart
new file mode 100644
index 0000000..a424ce1
--- /dev/null
+++ b/test/observable_map_test.dart
@@ -0,0 +1,376 @@
+// Copyright (c) 2016, 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 'package:observable/observable.dart';
+import 'package:test/test.dart';
+
+import 'observable_test_utils.dart';
+
+main() => _runTests();
+
+_runTests() {
+ // TODO(jmesserly): need all standard Map API tests.
+
+ StreamSubscription sub;
+
+ sharedTearDown() {
+ if (sub != null) {
+ sub.cancel();
+ sub = null;
+ }
+ }
+
+ group('observe length', () {
+ ObservableMap map;
+ List<ChangeRecord> changes;
+
+ setUp(() {
+ map = toObservable({'a': 1, 'b': 2, 'c': 3});
+ changes = null;
+ sub = map.changes.listen((records) {
+ changes = getPropertyChangeRecords(records, #length);
+ });
+ });
+
+ tearDown(sharedTearDown);
+
+ test('add item changes length', () {
+ map['d'] = 4;
+ expect(map, {'a': 1, 'b': 2, 'c': 3, 'd': 4});
+ return new Future(() {
+ expectChanges(changes, [_lengthChange(map, 3, 4)]);
+ });
+ });
+
+ test('putIfAbsent changes length', () {
+ map.putIfAbsent('d', () => 4);
+ expect(map, {'a': 1, 'b': 2, 'c': 3, 'd': 4});
+ return new Future(() {
+ expectChanges(changes, [_lengthChange(map, 3, 4)]);
+ });
+ });
+
+ test('remove changes length', () {
+ map.remove('c');
+ map.remove('a');
+ expect(map, {'b': 2});
+ return new Future(() {
+ expectChanges(changes, [
+ _lengthChange(map, 3, 2),
+ _lengthChange(map, 2, 1),
+ ]);
+ });
+ });
+
+ test('remove non-existent item does not change length', () {
+ map.remove('d');
+ expect(map, {'a': 1, 'b': 2, 'c': 3});
+ return new Future(() {
+ expectChanges(changes, null);
+ });
+ });
+
+ test('set existing item does not change length', () {
+ map['c'] = 9000;
+ expect(map, {'a': 1, 'b': 2, 'c': 9000});
+ return new Future(() {
+ expectChanges(changes, []);
+ });
+ });
+
+ test('clear changes length', () {
+ map.clear();
+ expect(map, {});
+ return new Future(() {
+ expectChanges(changes, [_lengthChange(map, 3, 0)]);
+ });
+ });
+ });
+
+ group('observe item', () {
+ ObservableMap map;
+ List<ChangeRecord> changes;
+
+ setUp(() {
+ map = toObservable({'a': 1, 'b': 2, 'c': 3});
+ changes = null;
+ sub = map.changes.listen((records) {
+ changes =
+ records.where((r) => r is MapChangeRecord && r.key == 'b').toList();
+ });
+ });
+
+ tearDown(sharedTearDown);
+
+ test('putIfAbsent new item does not change existing item', () {
+ map.putIfAbsent('d', () => 4);
+ expect(map, {'a': 1, 'b': 2, 'c': 3, 'd': 4});
+ return new Future(() {
+ expectChanges(changes, []);
+ });
+ });
+
+ test('set item to null', () {
+ map['b'] = null;
+ expect(map, {'a': 1, 'b': null, 'c': 3});
+ return new Future(() {
+ expectChanges(changes, [_changeKey('b', 2, null)]);
+ });
+ });
+
+ test('set item to value', () {
+ map['b'] = 777;
+ expect(map, {'a': 1, 'b': 777, 'c': 3});
+ return new Future(() {
+ expectChanges(changes, [_changeKey('b', 2, 777)]);
+ });
+ });
+
+ test('putIfAbsent does not change if already there', () {
+ map.putIfAbsent('b', () => 1234);
+ expect(map, {'a': 1, 'b': 2, 'c': 3});
+ return new Future(() {
+ expectChanges(changes, null);
+ });
+ });
+
+ test('change a different item', () {
+ map['c'] = 9000;
+ expect(map, {'a': 1, 'b': 2, 'c': 9000});
+ return new Future(() {
+ expectChanges(changes, []);
+ });
+ });
+
+ test('change the item', () {
+ map['b'] = 9001;
+ map['b'] = 42;
+ expect(map, {'a': 1, 'b': 42, 'c': 3});
+ return new Future(() {
+ expectChanges(changes, [
+ _changeKey('b', 2, 9001),
+ _changeKey('b', 9001, 42),
+ ]);
+ });
+ });
+
+ test('remove other items', () {
+ map.remove('a');
+ expect(map, {'b': 2, 'c': 3});
+ return new Future(() {
+ expectChanges(changes, []);
+ });
+ });
+
+ test('remove the item', () {
+ map.remove('b');
+ expect(map, {'a': 1, 'c': 3});
+ return new Future(() {
+ expectChanges(changes, [_removeKey('b', 2)]);
+ });
+ });
+
+ test('remove and add back', () {
+ map.remove('b');
+ map['b'] = 2;
+ expect(map, {'a': 1, 'b': 2, 'c': 3});
+ return new Future(() {
+ expectChanges(changes, [
+ _removeKey('b', 2),
+ _insertKey('b', 2),
+ ]);
+ });
+ });
+ });
+
+ test('toString', () {
+ var map = toObservable({'a': 1, 'b': 2});
+ expect(map.toString(), '{a: 1, b: 2}');
+ });
+
+ group('observe keys/values', () {
+ ObservableMap map;
+ int keysChanged;
+ int valuesChanged;
+
+ setUp(() {
+ map = toObservable({'a': 1, 'b': 2, 'c': 3});
+ keysChanged = 0;
+ valuesChanged = 0;
+ sub = map.changes.listen((records) {
+ keysChanged += getPropertyChangeRecords(records, #keys).length;
+ valuesChanged += getPropertyChangeRecords(records, #values).length;
+ });
+ });
+
+ tearDown(sharedTearDown);
+
+ test('add item changes keys/values', () {
+ map['d'] = 4;
+ expect(map, {'a': 1, 'b': 2, 'c': 3, 'd': 4});
+ return new Future(() {
+ expect(keysChanged, 1);
+ expect(valuesChanged, 1);
+ });
+ });
+
+ test('putIfAbsent changes keys/values', () {
+ map.putIfAbsent('d', () => 4);
+ expect(map, {'a': 1, 'b': 2, 'c': 3, 'd': 4});
+ return new Future(() {
+ expect(keysChanged, 1);
+ expect(valuesChanged, 1);
+ });
+ });
+
+ test('remove changes keys/values', () {
+ map.remove('c');
+ map.remove('a');
+ expect(map, {'b': 2});
+ return new Future(() {
+ expect(keysChanged, 2);
+ expect(valuesChanged, 2);
+ });
+ });
+
+ test('remove non-existent item does not change keys/values', () {
+ map.remove('d');
+ expect(map, {'a': 1, 'b': 2, 'c': 3});
+ return new Future(() {
+ expect(keysChanged, 0);
+ expect(valuesChanged, 0);
+ });
+ });
+
+ test('set existing item does not change keys', () {
+ map['c'] = 9000;
+ expect(map, {'a': 1, 'b': 2, 'c': 9000});
+ return new Future(() {
+ expect(keysChanged, 0);
+ expect(valuesChanged, 1);
+ });
+ });
+
+ test('clear changes keys/values', () {
+ map.clear();
+ expect(map, {});
+ return new Future(() {
+ expect(keysChanged, 1);
+ expect(valuesChanged, 1);
+ });
+ });
+ });
+
+ group('change records', () {
+ List<ChangeRecord> records;
+ ObservableMap map;
+
+ setUp(() {
+ map = toObservable({'a': 1, 'b': 2});
+ records = null;
+ map.changes.first.then((r) => records = r);
+ });
+
+ tearDown(sharedTearDown);
+
+ test('read operations', () {
+ expect(map.length, 2);
+ expect(map.isEmpty, false);
+ expect(map['a'], 1);
+ expect(map.containsKey(2), false);
+ expect(map.containsValue(2), true);
+ expect(map.containsKey('b'), true);
+ expect(map.keys.toList(), ['a', 'b']);
+ expect(map.values.toList(), [1, 2]);
+ var copy = {};
+ map.forEach((k, v) => copy[k] = v);
+ expect(copy, {'a': 1, 'b': 2});
+ return new Future(() {
+ // no change from read-only operators
+ expect(records, null);
+
+ // Make a change so the subscription gets unregistered.
+ map.clear();
+ });
+ });
+
+ test('putIfAbsent', () {
+ map.putIfAbsent('a', () => 42);
+ expect(map, {'a': 1, 'b': 2});
+
+ map.putIfAbsent('c', () => 3);
+ expect(map, {'a': 1, 'b': 2, 'c': 3});
+
+ return new Future(() {
+ expectChanges(records, [
+ _lengthChange(map, 2, 3),
+ _insertKey('c', 3),
+ _propChange(map, #keys),
+ _propChange(map, #values),
+ ]);
+ });
+ });
+
+ test('[]=', () {
+ map['a'] = 42;
+ expect(map, {'a': 42, 'b': 2});
+
+ map['c'] = 3;
+ expect(map, {'a': 42, 'b': 2, 'c': 3});
+
+ return new Future(() {
+ expectChanges(records, [
+ _changeKey('a', 1, 42),
+ _propChange(map, #values),
+ _lengthChange(map, 2, 3),
+ _insertKey('c', 3),
+ _propChange(map, #keys),
+ _propChange(map, #values),
+ ]);
+ });
+ });
+
+ test('remove', () {
+ map.remove('b');
+ expect(map, {'a': 1});
+
+ return new Future(() {
+ expectChanges(records, [
+ _removeKey('b', 2),
+ _lengthChange(map, 2, 1),
+ _propChange(map, #keys),
+ _propChange(map, #values),
+ ]);
+ });
+ });
+
+ test('clear', () {
+ map.clear();
+ expect(map, {});
+
+ return new Future(() {
+ expectChanges(records, [
+ _removeKey('a', 1),
+ _removeKey('b', 2),
+ _lengthChange(map, 2, 0),
+ _propChange(map, #keys),
+ _propChange(map, #values),
+ ]);
+ });
+ });
+ });
+}
+
+_lengthChange(map, int oldValue, int newValue) =>
+ new PropertyChangeRecord(map, #length, oldValue, newValue);
+
+_changeKey(key, old, newValue) => new MapChangeRecord(key, old, newValue);
+
+_insertKey(key, newValue) => new MapChangeRecord.insert(key, newValue);
+
+_removeKey(key, oldValue) => new MapChangeRecord.remove(key, oldValue);
+
+_propChange(map, prop) => new PropertyChangeRecord(map, prop, null, null);
diff --git a/test/observable_test.dart b/test/observable_test.dart
new file mode 100644
index 0000000..b89d654
--- /dev/null
+++ b/test/observable_test.dart
@@ -0,0 +1,222 @@
+// Copyright (c) 2016, 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 'package:observable/observable.dart';
+import 'package:test/test.dart';
+
+import 'observable_test_utils.dart';
+
+main() => observableTests();
+
+void observableTests() {
+ // Track the subscriptions so we can clean them up in tearDown.
+ List subs;
+
+ setUp(() {
+ subs = [];
+ });
+
+ tearDown(() {
+ for (var sub in subs) sub.cancel();
+ });
+
+ test('handle future result', () {
+ var callback = expectAsync(() {});
+ return new Future(callback);
+ });
+
+ test('no observers', () {
+ var t = createModel(123);
+ expect(t.value, 123);
+ t.value = 42;
+ expect(t.value, 42);
+ expect(t.hasObservers, false);
+ });
+
+ test('listen adds an observer', () {
+ var t = createModel(123);
+ expect(t.hasObservers, false);
+
+ subs.add(t.changes.listen((n) {}));
+ expect(t.hasObservers, true);
+ });
+
+ test('changes delived async', () {
+ var t = createModel(123);
+ int called = 0;
+
+ subs.add(t.changes.listen(expectAsync((records) {
+ called++;
+ expectPropertyChanges(records, 2);
+ })));
+
+ t.value = 41;
+ t.value = 42;
+ expect(called, 0);
+ });
+
+ test('cause changes in handler', () {
+ var t = createModel(123);
+ int called = 0;
+
+ subs.add(t.changes.listen(expectAsync((records) {
+ called++;
+ expectPropertyChanges(records, 1);
+ if (called == 1) {
+ // Cause another change
+ t.value = 777;
+ }
+ }, count: 2)));
+
+ t.value = 42;
+ });
+
+ test('multiple observers', () {
+ var t = createModel(123);
+
+ verifyRecords(records) {
+ expectPropertyChanges(records, 2);
+ }
+
+ subs.add(t.changes.listen(expectAsync(verifyRecords)));
+ subs.add(t.changes.listen(expectAsync(verifyRecords)));
+
+ t.value = 41;
+ t.value = 42;
+ });
+
+ test('async processing model', () {
+ var t = createModel(123);
+ var records = [];
+ subs.add(t.changes.listen((r) {
+ records.addAll(r);
+ }));
+ t.value = 41;
+ t.value = 42;
+ expectChanges(records, [], reason: 'changes delived async');
+
+ return new Future(() {
+ expectPropertyChanges(records, 2);
+ records.clear();
+
+ t.value = 777;
+ expectChanges(records, [], reason: 'changes delived async');
+ }).then(newMicrotask).then((_) {
+ expectPropertyChanges(records, 1);
+ });
+ });
+
+ test('cancel listening', () {
+ var t = createModel(123);
+ var sub;
+ sub = t.changes.listen(expectAsync((records) {
+ expectPropertyChanges(records, 1);
+ sub.cancel();
+ t.value = 777;
+ }));
+ t.value = 42;
+ });
+
+ test('cancel and reobserve', () {
+ var t = createModel(123);
+ var sub;
+ sub = t.changes.listen(expectAsync((records) {
+ expectPropertyChanges(records, 1);
+ sub.cancel();
+
+ scheduleMicrotask(() {
+ subs.add(t.changes.listen(expectAsync((records) {
+ expectPropertyChanges(records, 1);
+ })));
+ t.value = 777;
+ });
+ }));
+ t.value = 42;
+ });
+
+ test('cannot modify changes list', () {
+ var t = createModel(123);
+ var records;
+ subs.add(t.changes.listen((r) {
+ records = r;
+ }));
+ t.value = 42;
+
+ return new Future(() {
+ expectPropertyChanges(records, 1);
+
+ // Verify that mutation operations on the list fail:
+
+ expect(() {
+ records[0] = new PropertyChangeRecord(t, #value, 0, 1);
+ }, throwsUnsupportedError);
+
+ expect(() {
+ records.clear();
+ }, throwsUnsupportedError);
+
+ expect(() {
+ records.length = 0;
+ }, throwsUnsupportedError);
+ });
+ });
+
+ test('notifyChange', () {
+ var t = createModel(123);
+ var records = [];
+ subs.add(t.changes.listen((r) {
+ records.addAll(r);
+ }));
+ t.notifyChange(new PropertyChangeRecord(t, #value, 123, 42));
+
+ return new Future(() {
+ expectPropertyChanges(records, 1);
+ expect(t.value, 123, reason: 'value did not actually change.');
+ });
+ });
+
+ test('notifyPropertyChange', () {
+ var t = createModel(123);
+ var records;
+ subs.add(t.changes.listen((r) {
+ records = r;
+ }));
+ expect(t.notifyPropertyChange(#value, t.value, 42), 42,
+ reason: 'notifyPropertyChange returns newValue');
+
+ return new Future(() {
+ expectPropertyChanges(records, 1);
+ expect(t.value, 123, reason: 'value did not actually change.');
+ });
+ });
+}
+
+expectPropertyChanges(records, int number) {
+ expect(records.length, number, reason: 'expected $number change records');
+ for (var record in records) {
+ expect(record is PropertyChangeRecord, true,
+ reason: 'record should be PropertyChangeRecord');
+ expect((record as PropertyChangeRecord).name, #value,
+ reason: 'record should indicate a change to the "value" property');
+ }
+}
+
+createModel(int number) => new ObservableSubclass(number);
+
+class ObservableSubclass<T> extends Observable {
+ ObservableSubclass([T initialValue]) : _value = initialValue;
+
+ T get value => _value;
+ set value(T newValue) {
+ T oldValue = _value;
+ _value = newValue;
+ notifyPropertyChange(#value, oldValue, newValue);
+ }
+
+ T _value;
+
+ String toString() => '#<$runtimeType value: $value>';
+}
diff --git a/test/observable_test_utils.dart b/test/observable_test_utils.dart
new file mode 100644
index 0000000..91d4d8f
--- /dev/null
+++ b/test/observable_test_utils.dart
@@ -0,0 +1,32 @@
+// Copyright (c) 2016, 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 observable.test.observable_test_utils;
+
+import 'dart:async';
+
+import 'package:observable/observable.dart';
+import 'package:test/test.dart';
+
+/// A small method to help readability. Used to cause the next "then" in a chain
+/// to happen in the next microtask:
+///
+/// future.then(newMicrotask).then(...)
+///
+/// Uses [mu].
+newMicrotask(_) => new Future.value();
+
+// TODO(jmesserly): use matchers when we have a way to compare ChangeRecords.
+// For now just use the toString.
+void expectChanges(actual, expected, {String reason}) =>
+ expect('$actual', '$expected', reason: reason);
+
+List<ListChangeRecord> getListChangeRecords(
+ List<ListChangeRecord> changes, int index) =>
+ new List.from(changes.where((ListChangeRecord c) => c.indexChanged(index)));
+
+List<PropertyChangeRecord> getPropertyChangeRecords(
+ List<ChangeRecord> changes, Symbol property) =>
+ new List.from(changes.where(
+ (ChangeRecord c) => c is PropertyChangeRecord && c.name == property));
