Initial stream support

lib/eval.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library fancy_syntax.eval;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 
 import 'package:mdv_observe/mdv_observe.dart';
 
+import 'async.dart';
 import 'expression.dart';
 import 'filter.dart';
 import 'visitor.dart';
 import 'parser.dart';
+import 'src/mirrors.dart';
 
 final _BINARY_OPERATORS = {
   '+':  (a, b) => a + b,
   '-':  (a, b) => a - b,
   '*':  (a, b) => a * b,
   '/':  (a, b) => a / b,
   '==': (a, b) => a == b,
   '!=': (a, b) => a != b,
   '>':  (a, b) => a > b,
   '>=': (a, b) => a >= b,
   '<':  (a, b) => a < b,
   '<=': (a, b) => a <= b,
   '||': (a, b) => a || b,
   '&&': (a, b) => a && b,
   '|':  (a, f) {
     if (f is Transformer) return f.forward(a);
     if (f is Filter) return f(a);
     throw new EvalException("Filters must be a one-argument function.");
   }
 };
 
 final _UNARY_OPERATORS = {
   '+': (a) => a,
   '-': (a) => -a,
   '!': (a) => !a,
 };
 
+final _BOOLEAN_OPERATORS = ['!', '||', '&&'];
+
 /**
  * Evaluation [expr] in the context of [scope].
  */
 Object eval(Expression expr, Scope scope) => observe(expr, scope)._value;
 
 
 ExpressionObserver observe(Expression expr, Scope scope) {
   var observer = new ObserverBuilder(scope).visit(expr);
   new Updater(scope).visit(observer);
   return observer;
@@ skipping 79 matching lines @@
       : _variables = new ObservableMap.from(variables);
 
   InstanceMirror get _modelMirror {
     if (__modelMirror != null) return __modelMirror;
     __modelMirror = reflect(model);
     return __modelMirror;
   }
 
   Object operator[](String name) {
     if (_variables.containsKey(name)) {
-      return _variables[name];
+      return _convert(_variables[name]);
     } else if (model != null) {
       var symbol = new Symbol(name);
       var classMirror = _modelMirror.type;
-      if (classMirror.variables.containsKey(symbol) ||
-          classMirror.getters.containsKey(symbol)) {
-        return _modelMirror.getField(symbol).reflectee;
-      } else if (classMirror.methods.containsKey(symbol)) {
+      var memberMirror = getMemberMirror(classMirror, symbol);
+      if (memberMirror is VariableMirror ||
+          (memberMirror is MethodMirror && memberMirror.isGetter)) {
+        return _convert(_modelMirror.getField(symbol).reflectee);
+      } else if (memberMirror is MethodMirror) {
         return new Method(_modelMirror, symbol);
       }
     }
     if (parent != null) {
-      return parent[name];
+      return _convert(parent[name]);
     } else {
       throw new EvalException("variable not found: $name in $hashCode");
     }
   }
 
   Object ownerOf(String name) {
     if (_variables.containsKey(name)) {
       return _variables;
     } else {
       var symbol = new Symbol(name);
       var classMirror = _modelMirror.type;
-      if (classMirror.variables.containsKey(symbol) ||
-          classMirror.getters.containsKey(symbol) ||
-          classMirror.methods.containsKey(symbol)) {
+      if (getMemberMirror(classMirror, symbol) != null) {
         return model;
       }
     }
     if (parent != null) {
       return parent.ownerOf(name);
     }
   }
+
+  bool contains(String name) {
+    if (_variables.containsKey(name)) {
+      return true;
+    } else {
+      var symbol = new Symbol(name);
+      var classMirror = _modelMirror.type;
+      if (getMemberMirror(classMirror, symbol) != null) {
+        return true;
+      }
+    }
+    if (parent != null) {
+      return parent.contains(name);
+    }
+    return false;
+  }
+
+  String toString() => 'Scope($hashCode $parent)';
+}
+
+Object _convert(v) {
+  if (v is Stream) return new StreamBinding(v);
+  return v;
 }
 
 abstract class ExpressionObserver<E extends Expression> implements Expression {
   final E _expr;
   ExpressionObserver _parent;
 
   StreamSubscription _subscription;
   Object _value;
 
   StreamController _controller = new StreamController.broadcast();
@@ skipping 222 matching lines @@
 
   String get method => _expr.method;
 
   _updateSelf(Scope scope) {
     var args = (arguments == null)
         ? []
         : arguments.map((a) => a._value)
             .toList(growable: false);
     var receiverValue = receiver._value;
     if (receiverValue == null) {
-      return null;
-    }
-    if (_expr.method == null) {
+      _value = null;
+    } else if (_expr.method == null) {
       if (_expr.isGetter) {
         _value = receiverValue;
       } else {
         assert(receiverValue is Function);
         _value = call(receiverValue, args);
       }
     } else {
       // special case [] because we don't need mirrors
       if (_expr.method == '[]') {
         assert(args.length == 1);
@@ skipping 36 matching lines @@
     _value = new Comprehension(identifier.value, iterable);
   }
 
   accept(Visitor v) => v.visitInExpression(this);
 }
 
 _toBool(v) => (v == null) ? false : v;
 
 call(dynamic receiver, List args) {
   if (receiver is Method) {
-    return receiver.mirror.invoke(receiver.symbol, args, null).reflectee;
+    return
+        _convert(receiver.mirror.invoke(receiver.symbol, args, null).reflectee);
   } else {
-    return Function.apply(receiver, args, null);
+    return _convert(Function.apply(receiver, args, null));
   }
 }
 
 /**
  * A comprehension declaration ("a in b").
  */
 class Comprehension {
   final String identifier;
   final Iterable iterable;
   Comprehension(this.identifier, this.iterable);
 }
 
 /**
  * A method on a model object in a [Scope].
  */
 class Method { //implements _FunctionWrapper {
   final InstanceMirror mirror;
   final Symbol symbol;
 
   Method(this.mirror, this.symbol);
 
   dynamic call(List args) => mirror.invoke(symbol, args, null).reflectee;
 }
 
 class EvalException implements Exception {
   final String message;
   EvalException(this.message);
   String toString() => "EvalException: $message";
 }