radiant-fabulator_exhibit-extension 0.0.1 → 0.0.2

data/public/javascripts/fabulator/exhibit/exhibit.js

@@ -0,0 +1,160 @@
+/*
+ *  (c) Copyright Texas A&M University 2010.  All rights reserved.
+ *
+ * Portions of this code are copied from The SIMILE Project:
+ *  (c) Copyright The SIMILE Project 2006. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *
+ */
+
+// We can assume the Infusion is loaded
+
+/*
+ * An Exhibit consists of the presentation and an overlay or slide-out
+ * with facets
+ */
+
+/* We look for <div class="fabulator-exhibit" /> sections */
+
+/*
+ * A view offers a filtered set of data from a data store
+ * A data store manages the actual data from the server
+ * An Exhibit interacts with the view to manage the data shown
+ */
+
+Fabulator.namespace('Exhibit');
+
+(function($, Exhibit) {
+
+  var initDataView = function(that) {
+    that.dataView = Exhibit.DataView({ source: that.options.source });
+    that.dataView.events.onModelChange.addListener(that.eventModelChange);
+    that.registerFilter = function(filter) {
+      that.dataView.registerFilter(filter);
+    };
+  };
+
+  var initPresentationViews = function(that) {
+    $(that.container).find('.views').each(function(idx, el) {
+      $(el).addClass("ui-corner-all");
+      that.presentation = Exhibit.Presentations(el, { viewPanel: that });
+    });
+  };
+
+  var initFacetView = function(that, myid) {
+    $(that.container).find('.facets').each(function(idx, el) {
+      $(el).attr('id', myid+'-facets-' + idx);
+      that.facets = Exhibit.Facets(el, { viewPanel: that, trigger: '#' + myid + '-open-facets' });
+    });
+  };
+
+  Exhibit.ViewPanel = function(container, options) {
+    var that = fluid.initView("Fabulator.Exhibit.ViewPanel", container, options),
+        lenses = new Array(),
+        header, counters,
+        myid = $(container).attr('id');
+
+    options = that.options;
+
+    options.source = options.source || $(container).attr("source");
+
+    that.eventModelChange = function(model) {
+
+      that.setCount(model.size());
+
+      if(that.presentation) {
+        that.presentation.eventModelChange(model);
+      }
+
+    };
+
+    lenses.push(Exhibit.DefaultLens());
+
+    that.getLens = function(item) {
+      for(i = 0, n = lenses.length; i < n; i++) {
+        if(lenses[i].isForItem(item)) {
+          return lenses[i];
+        }
+      }
+    }
+
+
+    header = "<span class='title'>" + $(container).attr("ex:exhibitLabel") + "</span>";
+
+    counters = $(container).attr("ex:counters");
+
+    if( counters != null) {
+      counters = counters.split(':');
+      header += "<span class='counter' id='" + myid + "-counter'>0 " + counters[1] + "</span>";
+    }
+
+    if( $(that.container).find('.facets').size() > 0 ) {
+      header += "<span class='ui-icon ui-icon-gear' id='"+myid+"-open-facets'>facets</span>";
+    }
+    $("<div class='header ui-corner-all'>" + header + "</div>").prependTo($(container));
+    //$("<div class='header ui-corner-all'><span class='title'>" + $(container).attr("ex:exhibitLabel") + "</span><span class='counter' id='" + myid + "-counter'>0 Items</span><span class='ui-icon ui-icon-gear' id='"+myid+"-open-facets'>facets</span></div>").prependTo($(container));
+
+    that.setCount = function(count) {
+      if( counters != null ) {
+        $('#' + myid + '-counter').text(count + " " + (count == 1 ? counters[0] : counters[1]));
+      }
+    }
+
+    initDataView(that);
+
+    initPresentationViews(that);
+
+    initFacetView(that, myid);
+
+    that.dataView.dataSource.fetchData();
+
+
+    return that;
+  };
+})(jQuery, Fabulator.Exhibit);
+
+fluid.defaults("Fabulator.Exhibit.ViewPanel", {
+  Presentations: {
+    type: "Fabulator.Exhibit.Presentations",
+  },
+  Facets: {
+    type: "Fabulator.Exhibit.Facets",
+  },
+  events: {
+    onDataChange: null
+  }
+});
+
+/* The following is what goes into the HTML through the xslt */
+jQuery(document).ready(function($){
+  $(".fabulator-exhibit").each(function(idx, el) {
+    var options = {
+    };
+
+    Fabulator.Exhibit.ViewPanel('#' + $(el).attr('id'), options);
+  });
+});

data/public/javascripts/fabulator/exhibit/expressions.js

@@ -0,0 +1,1028 @@
+/*
+ *  (c) Copyright Texas A&M University 2010.  All rights reserved.
+ *
+ * Portions of this code are copied from The SIMILE Project:
+ *  (c) Copyright The SIMILE Project 2006. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. 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.
+ * 
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *
+ */
+
+(function($, Exhibit) {
+  Exhibit.Controls = { 
+    "if": {
+      f: function(args, roots, rootValueTypes, defaultRootName, database) {
+           var conditionCollection = args[0].evaluate(roots, rootValueTypes, defaultRootName, database),
+               condition = false;
+           conditionCollection.forEachValue(function(v) {
+             if(v) {
+               condition = true;
+               return true;
+             }
+           });
+
+           if(condition) {
+             return args[1].evaluate(roots, rootValueTypes, defaultRootName, database);
+           } 
+           else {
+             return args[2].evaluate(roots, rootValueTypes, defaultRootName, database);
+           }
+         }
+      },
+    "foreach": {
+      f: function(args, roots, rootValueTypes, defaultRootName, database) {
+           var collection = args[0].evaluate(roots, rootValueTypes, defaultRootName, database),
+               oldValue = roots["value"],
+               oldValueType = rootValueTypes["value"],
+               results = [ ],
+               valueType = "text",
+               collection2;
+
+           rootValueTypes["value"] = collection.valueType;
+
+           collection.forEachValue(function(element) {
+             roots["value"] = element;
+             collection2 = args[1].evaluate(roots, rootValueTypes, defaultRootName, database);
+             valueType = collection2.valueType;
+
+             collection2.forEachValue(function(result) {
+               results.push(result);
+             });
+           });
+
+           roots["value"] = oldValue;
+           rootValueTypes["value"] = oldValueType;
+
+           return Exhibit.Expression.Collection(results, valueType);
+         }
+      },
+    "default": {
+      f: function(args, roots, rootValueTypes, defaultRootName, database) {
+        var i, n, collection;
+        for(i = 0, n = args.length; i < n; i++) {
+          collection = args[i].evaluate(roots, rootValueTypes, defaultRootName, database);
+          if( collection.size() > 0 ) {
+            return collection;
+          }
+        }
+        return Exhibit.Expression.Collection([], "text");
+      }
+    }
+  };
+
+  Exhibit.Expression = function(rootNode) {
+    var that = { };
+
+    that.evaluate = function(
+      roots, 
+      rootValueTypes, 
+      defaultRootName, 
+      database
+    ) {
+      var collection = rootNode.evaluate(roots, rootValueTypes, defaultRootName, database);
+      return {
+        values:    collection.getSet(),
+        valueType: collection.valueType,
+        size:      collection.size()
+      };
+    };
+
+    that.evaluateOneItem = function( itemID, database ) {
+      return this.evaluate(
+        { "value" : itemID },
+        { "value" : "item" },
+        "value",
+        database
+      );
+    };
+
+    that.evaluateSingle = function(
+      roots,
+      rootValueTypes,
+      defaultRootName,
+      database
+    ) {
+      var collection = rootNode.evaluate(roots, rootValueTypes, defaultRootName, database),
+          result = { value: null, valueType: collection.valueType };
+
+      collection.forEachValue(function(v) {
+        result.value = v;
+        return true;
+      });
+
+      return result;
+    };
+
+    that.isPath = rootNode.isPath;
+
+    that.getPath = that.isPath ?
+      function() { return rootNode; } :
+      function() { return null;     } ;
+
+    that.testExists = that.isPath ?
+      function(
+        roots,
+        rootValueTypes,
+        defaultRootName,
+        database
+      ) {
+        return rootNode.testExists(roots, rootValueTypes, defaultRootName, database);
+      } :
+      function(
+        roots,
+        rootValueTypes,
+        defaultRootName,
+        database
+      ) {
+        return that.evaluate(roots, rootValueTypes, defaultRootName, database).values.size() > 0;
+      };
+
+    that.evaluateBackward = function(
+      value,
+      valueType,
+      filter,
+      database  
+    ) {
+      return rootNode.walkBackward([ value ], valueType, filter, database);
+    };   
+       
+    that.walkForward = function(
+      values, 
+      valueType,
+      database
+    ) {
+      return rootNode.walkForward(values, valueType, database);
+    };      
+    
+    that.walkBackward = function(
+      values,
+      valueType,
+      filter, 
+      database
+    ) {
+      return rootNode.walkBackward(values, valueType, filter, database);
+    };
+
+    return that;
+  };
+
+  Exhibit.Expression.Collection = function(values, valueType) {
+    var that = { };
+
+    if( values instanceof Array ) {
+
+      that.forEachValue = function(f) {
+        var a = values,
+            i, n;
+
+        for(i = 0, n = a.length; i < n; i++) {
+          if( f(a[i]) === true ) {
+            break;
+          }
+        }
+      };
+
+      that.getSet = function() {
+        return Exhibit.Set(values);
+      };
+
+      that.contains = function(v) {
+        var a = values,
+            i, n;
+
+        for(i = 0, n = a.length; i < n; i++) {
+          if( a[i] == v ) { return true; }
+        }
+        return false;
+      };
+
+      that.size = function() { values.length; };
+
+    }
+    else {
+
+      that.forEachValue = function(f) {
+        values.visit(f);
+      };
+
+      that.getSet = function() {
+        return values;
+      };
+
+      that.contains = function(v) {
+        return values.contains(v);
+      };
+
+      that.size = values.size;
+
+    }
+
+    that.isPath = false;
+
+    return that;
+  };
+
+  Exhibit.Expression.Constant = function(value, valueType) {
+    var that = { };
+
+    that.evaluate = function(
+      roots,
+      rootValueTypes,
+      defaultRootName,
+      database
+    ) {
+      return Exhibit.Expression.Collection([ value ], valueType);
+    };
+
+    that.isPath = false;
+
+    return that;
+  };
+
+  var _operators = {
+    "+" : {
+      argumentType: "number",
+      valueType: "number",
+      f: function(a,b) { return a+b; }
+    },
+    "-" : {
+      argumentType: "number",
+      valueType: "number",
+      f: function(a,b) { return a-b; }
+    },
+    "*" : {
+      argumentType: "number",
+      valueType: "number",
+      f: function(a,b) { return a*b; }
+    },
+    "/" : {
+      argumentType: "number",
+      valueType: "number",
+      f: function(a,b) { return a/b; }
+    },
+    "=" : {
+      valueType: "boolean",
+      f: function(a,b) { return a == b; }
+    },
+    "<>" : {
+      valueType: "boolean",
+      f: function(a,b) { return a != b; }
+    },
+    "><" : {
+      valueType: "boolean",
+      f: function(a,b) { return a != b; }
+    },
+    "<" : {
+      valueType: "boolean",
+      f: function(a,b) { return a < b; }
+    },
+    ">" : {
+      valueType: "boolean",
+      f: function(a,b) { return a > b; }
+    },
+    "<=" : {
+      valueType: "boolean",
+      f: function(a,b) { return a <= b; }
+    },
+    ">=" : {
+      valueType: "boolean",
+      f: function(a,b) { return a >= b; }
+    }
+  };
+
+  Exhibit.Expression.Operator = function(operator, args) {
+    var that      = { },
+        _operator = operator,
+        _args     = args;
+
+    that.evaluate = function(
+      roots,
+      rootValueTypes,
+      defaultRootName,
+      database
+    ) {
+      var values = [ ],
+          args = [],
+          i, n, operator, f;
+
+      for(i = 0, n = _args.length; i < n; i++) {
+        args.push(_args[i].evaluate(roots, rootValueTypes, defaultRootName, database));
+      }
+
+      operator = _operators[_operator];
+      f = operator.f;
+      if(operator.argumentType == "number") {
+        args[0].forEachValue(function(v1) {
+          if( !(typeof(v1) == "number") ) {
+            v1 = parseFloat(v1);
+          }
+
+          args[1].forEachValue(function(v2) {
+            if( !(typeof(v2) == "number")) {
+              v2 = parseFloat(v2);
+            }
+ 
+            values.push(f(v1, v2));
+          });
+        });
+      }
+      else {
+        args[0].forEachValue(function(v1) {
+          args[1].forEachValue(function(v2) {
+            values.push(f(v1, v2));
+          });
+        });
+      }
+
+      return Exhibit.Expression.Collection(values, operator.valueType);
+    };
+
+    that.isPath = false;
+
+    return that;
+  };
+
+  Exhibit.Expression.FunctionCall = function(name, args) {
+    var that = { },
+        _name = name,
+        _args = args;
+
+    that.evaluate = function(
+      roots,
+      rootValueTypes,
+      defaultRootName,
+      database
+    ) {
+      var args = [],
+          i, n;
+
+      for(i = 0, n = _args.length; i < n; i++) {
+        args.push(_args[i].evaluate(roots, rootValueTypes, defaultRootName, database));
+      }
+
+      if(_name in Exhibit.Functions) {
+        return Exhibit.Functions[_name].f(args);
+      }
+      else {
+        throw new Error("No such function named " + _name);
+      }
+    };
+
+    that.isPath = false;
+
+    return that;
+  };
+
+  Exhibit.Expression.ControlCall = function(name, args) {
+    var that = { },
+        _name = name,
+        _args = args;
+
+    that.evaluate = function(
+      roots,
+      rootValueTypes,
+      defaultRootName,
+      database
+    ) {
+      return Exhibit.Controls[_name].f(_args, roots, rootValueTypes, defaultRootName, database);
+    };
+
+    that.isPath = false;
+
+    return that;
+  };
+
+  Exhibit.Expression.Path = function(property, forward) {
+    var that = { },
+        _rootName = null,
+        _segments = [ ];
+
+    if( typeof(property) != "undefined" ) {
+      _segments.push({ property: property, forward: forward, isArray: false });
+    }
+
+    that.isPath = true;
+
+    that.setRootName = function(rootName) {
+      _rootName = rootName;
+    };
+
+    that.appendSegment = function(property, hopOperator) {
+      _segments.push({
+        property: property,
+        forward: hopOperator.charAt(0) == ".",
+        isArray: hopOperator.length > 1
+      });
+    };
+
+    that.getSegment = function(index) {
+      var segment;
+
+      if( index < _segments.length ) {
+        segment = _segments[index];
+        return {
+          property: segment.property,
+          forward:  segment.forward,
+          isArray:  segment.isArray
+        };
+      }
+      else {
+        return null;
+      }
+    };
+
+    that.getLastSegment = function() {
+      return that.getSegment(_segments.length - 1);
+    };
+
+    that.getSegmentCount = function() { return _segments.length };
+
+    var walkForward = function(collection, database) {
+      var i, n, segment, a, valueType, property, values;
+
+      for(i = 0, n = _segments.length; i < n; i++) {
+        segment = _segments[i];
+        if(segment.isArray) {
+          a = [ ];
+          if( segment.forward ) {
+            collection.forEachValue(function(v) {
+              database.getObjects(v, segment.property).visit(function(v2) { a.push(v2); });
+            });
+
+            property = database.getProperty(segment.property);
+            valueType = property != null ? property.getValueType() : "text";
+          }
+          else {
+            collection.forEachValue(function(v) {
+              database.getSubjects(v, segment.property).visit(function(v2) { a.push(v2); });
+            });
+            valueType = "item";
+          }
+          collection = Exhibit.Expression.Collection(a, valueType);
+        }
+        else {
+          if( segment.forward ) {
+            values = database.getObjectsUnion(collection.getSet(), segment.property);
+            property = database.getProperty(segment.property);
+            valueType = property != null ? property.getValueType() : "text";
+            collection = Exhibit.Expression.Collection(values, valueType);
+          }
+          else {
+            values = database.getSubjectsUnion(collection.getSet(), segment.property);
+            collection = Exhibit.Expression.Collection(values, "item");
+          }
+        }
+      }
+
+      return collection;
+    };
+
+    var walkBackward = function(collection, filter, database) {
+      var i, segment, a, valueType, property, values;
+
+      if(filter instanceof Array) {
+        filter = Exhibit.Set(filter);
+      }
+      for(i = _segments.length - 1; i >= 0; i--) {
+        segment = _segments[i];
+        if(segment.isArray) {
+          a = [];
+          if( segment.forward ) {
+            collection.forEachValue(function(v) {
+              database.getSubjects(v, segment.property).visit(function(v2) {
+                if( i > 0 || filter == null || filter.contains(v2) ) {
+                  a.push(v2);
+                }
+              });
+            });
+
+            property = database.getProperty(segment.property);
+            valueType = property != null ? property.getValueType() : "text";
+          }
+          else {
+            collection.forEachValue(function(v) {
+              database.getObjects(v, segment.property).visit(function(v2) {
+                if( i > 0 || filter == null || filter.contains(v2) ) {
+                  a.push(v2);
+                }
+              });
+            });
+            valueType = "item";
+          }
+          collection = Exhibit.Expression.Collection(a, valueType);
+        }
+        else {
+          if( segment.forward ) {
+            values = database.getSubjectsUnion(collection.getSet(), segment.property, null, i == 0 ? filter : null);
+            collection = Exhibit.Expression.Collection(values, "item");
+          }
+          else {
+            values = database.getObjectsUnion(collection.getSet(), segment.property, null, i == 0 ? filter : null);
+            property = database.getProperty(segment.property);
+            valueType = property != null ? property.getValueType() : "text";
+            collection = Exhibit.Expression.Collection(values, valueType);
+          }
+        }
+      }
+
+      return collection;
+    };
+
+    that.rangeBackward = function(
+      from,
+      to,
+      filter,
+      database
+    ) {
+      var set = Exhibit.Set(),
+          valueType = "item",
+          segment, i;
+
+      if(_segments.length > 0) {
+        segment = _segments[_segments.length - 1];
+        if(segment.forward) {
+          database.getSubjectsInRange(segment.property, from, to, false, set, _segments.length == 1 ? filter : null);
+        }
+        else {
+          throw new Error("Last path of segment must be forward");
+        }
+
+        for(i = _segments.length-2; i >= 0; i--) {
+          segment = _segments[i];
+          if( segment.forward ) {
+            set = database.getSubjectsUnion(set, segment.property, null, i == 0 ? filter : null);
+            valueType = "item";
+          }
+          else {
+            set = database.getObjectsUnion(set, segment.property, null, i == 0 ? filter : null);
+            property = database.getProperty(segment.property);
+            valueType = property != null ? property.getValueType() : "text";
+          }
+        }
+      }
+
+      return {
+        valueType: valueType,
+        values:    set,
+        count:     set.size()
+      };
+    };
+
+    that.evaluate = function(
+      roots,
+      rootValueTypes,
+      defaultRootName,
+      database
+    ) {
+      var rootName = _rootName != null ? _rootName : defaultRootName,
+          valueType = rootName in rootValueTypes ? rootValueTypes[rootName] : "text",
+          collection = null,
+          root;
+
+      if( rootName in roots ) {
+        root = roots[rootName];
+
+        if( root.isSet || root instanceof Array) {
+          collection = Exhibit.Expression.Collection(root, valueType);
+        }
+        else {
+          collection = Exhibit.Expression.Collection([ root ], valueType);
+        }
+
+        return walkForward(collection, database);
+      }
+      else {
+        throw new Error("No such variable called " + rootName);
+      }
+    };
+
+    that.testExists = function(
+      roots,
+      rootValueTypes,
+      defaultRootName,
+      database
+    ) {
+      return that.evaluate(roots, rootValueTypes, defaultRootName, database).size() > 0;
+    };
+
+    that.evaluateBackward = function(
+      value,
+      valueType,
+      filter,
+      database
+    ) {
+      var collection = Exhibit.Expression.Collection([ value ], valueType);
+      return walkBackward(collection, filter, database);
+    };
+
+    that.walkForward = function(
+      values,
+      valueType,
+      database
+    ) {
+      return walkForward(Exhibit.Expression.Collection(values, valueType), database);
+    };
+
+    that.walkBackward = function(
+      values,
+      valueType,
+      filter,
+      database
+    ) {
+      return walkBackward(Exhibit.Expression.Collection(values, valueType), filter, database);
+    };
+    
+    return that;
+  };
+
+  Exhibit.ExpressionParser = function() {
+    var that = { };
+
+    var internalParse = function(scanner, several) {
+      var token = scanner.token(),
+          roots, expressions, r, n,
+          Scanner = Exhibit.ExpressionScanner,
+          next = function() { scanner.next(); token = scanner.token(); },
+          makePosition = function() { return token != null ? token.start : scanner.index(); };
+
+      var parsePath = function() {
+            var path = Exhibit.Expression.Path(),
+                hopOperator;
+            while( token != null && token.type == Scanner.PATH_OPERATOR ) {
+              hopOperator = token.value;
+              next();
+
+              if( token != null && token.type == Scanner.IDENTIFIER ) {
+                path.appendSegment(token.value, hopOperator);
+                next();
+              }
+              else {
+                throw new Error("Missing property ID at position " + makePosition());
+              }
+            }
+            return path;
+          };
+
+      var parseFactor = function() {
+        var result = null,
+            identifier;
+
+        if( token == null ) {
+          throw new Error("Missing factor at end of expression");
+        }
+
+        switch(token.type) {
+        case Scanner.NUMBER:
+          result = Exhibit.Expression.Constant(token.value, "number");
+          next();
+          break;
+        case Scanner.STRING:
+          result = Exhibit.Expression.Constant(token.value, "text");
+          next();
+          break;
+        case Scanner.PATH_OPERATOR:
+          result = parsePath();
+          break;
+        case Scanner.IDENTIFIER:
+          identifier = token.value;
+          next();
+
+          if( identifier in Exhibit.Controls ) {
+            if( token != null && token.type == Scanner.DELIMITER && token.value == "(") {
+              next();
+
+              args = (token != null && token.type == Scanner.DELIMITER && token.value == ")") ?
+                     [] : parseExpressionList();
+              result = Exhibit.Expression.ControlCall(identifier, args);
+
+              if( token != null && token.type == Scanner.DELIMITER && token.value == ")") {
+                next();
+              }
+              else {
+                throw new Error("Missing ) to end " + identifier + " at position " + makePosition());
+              }
+            }
+            else {
+              throw new Error("Missing ( to start " + identifier + " at position " + makePosition());
+            }
+          }
+          else {
+            if( token != null && token.type == Scanner.DELIMITER && token.value == "(") {
+              next();
+
+              args = (token != null && token.type == Scanner.DELIMITER && token.value == ")") ?
+                     [] : parseExpressionList();
+              result = Exhibit.Expression.FunctionCall(identifier, args);
+
+              if( token != null && token.type == Scanner.DELIMITER && token.value == ")") {
+                next();
+              }
+              else {
+                throw new Error("Missing ) after function call " + identifier + " at position " + makePosition());
+              }
+            }
+            else {
+              result = parsePath();
+              result.setRootName(identifier);
+            }
+          }
+          break;
+        case Scanner.DELIMITER:
+          if( token.value == "(" ) {
+            next();
+
+            result = parseExpression();
+            if( token != null && token.type == Scanner.DELIMITER && token.value == ")") {
+              next();
+              break;
+            }
+            else {
+              throw new Error("Missing ) at position " + makePosition());
+            }
+          } // else, fall through
+        default:
+          throw new Error("Unexpected text " + token.value + " at position " + makePosition());
+        }
+
+        return result;
+      };
+
+      var parseTerm = function() {
+        var term = parseFactor(),
+            operator;
+
+        while( token != null && token.type == Scanner.OPERATOR &&
+           ( token.value == "*" || token.value == "/" )) {
+          operator = token.value;
+          next();
+
+          term = Exhibit.Expression.Operator(operator, [ term, parseFactor() ]);
+        }
+        return term;
+      };
+
+      var parseSubExpression = function() {
+        var subExpression = parseTerm(),
+            operator;
+
+        while( token != null && token.type == Scanner.OPERATOR &&
+           ( token.value == "+" || token.value == "-" )) {
+          operator = token.value;
+          next();
+
+          subExpression = Exhibit.Expression.Operator(operator, [ subExpression, parseTerm() ]);
+        }
+        return subExpression;
+      };
+
+      var parseExpression = function() {
+        var expression = parseSubExpression(),
+          operator;
+
+        while( token != null && token.type == Scanner.OPERATOR &&
+          ( token.value == "=" || token.value == "<>" ||
+            token.value == "<" || token.value == "<=" ||
+            token.value == ">" || token.value == ">=" )) {
+
+          operator = token.value;
+          next();
+
+          expression = Exhibit.Expression.Operator(operator, [ expression, parseSubExpression ]);
+        }
+        return expression;
+      };
+
+      var parseExpressionList = function() {
+        var expressions = [ parseExpression() ];
+        while( token != null && token.type == Scanner.DELIMITER && token.value == ",") {
+          next();
+          expressions.push(parseExpression());
+        }
+        return expressions;
+      };
+
+      if(several) {
+        roots = parseExpressionList();
+        expressions = [ ];
+        for(r = 0, n = roots.length; r < n; r++) {
+          expressions.push(Exhibit.Expression(roots[r]));
+        }
+        return expressions;
+      }
+      else {
+        return Exhibit.Expression(parseExpression());
+      }
+    };
+
+    that.parse = function(s, startIndex, results) {
+      var scanner;
+
+      startIndex = startIndex || 0;
+      results = results || { };
+
+      scanner = Exhibit.ExpressionScanner(s, startIndex);
+      try {
+        return internalParse(scanner, false);
+      } 
+      finally {
+        results.index = scanner.token() != null ? scanner.token().start : scanner.index();
+      }
+    };
+
+
+    return that;
+  };
+
+  Exhibit.ExpressionScanner = function(text, startIndex) {
+    var that = { },
+        _text = text + " ",
+        _maxIndex = text.length,
+        _index = startIndex,
+        _token = null;
+
+    
+
+    that.token = function() { return _token; }
+
+    that.index = function() { return _index; }
+
+    var isDigit = function(c) {
+      return "0123456789".indexOf(c) >= 0;
+    };
+
+    that.next = function() {
+      var c1, c2, i, c;
+
+      _token = null;
+
+      while(_index < _maxIndex &&
+        " \t\r\n".indexOf(_text.charAt(_index)) >= 0) {
+        _index++;
+      };
+
+      if( _index < _maxIndex ) {
+        c1 = _text.charAt(_index);
+        c2 = _text.charAt(_index + 1);
+
+        if( ".!".indexOf(c1) >= 0 ) {
+          if( c2 == "@" ) {
+            _token = {
+              type: Exhibit.ExpressionScanner.PATH_OPERATOR,
+              value: c1+c2,
+              start: _index,
+              end: _index+2
+            };
+            _index += 2;
+          }
+          else {
+            _token = {
+              type: Exhibit.ExpressionScanner.PATH_OPERATOR,
+              value: c1,
+              start: _index,
+              end:   _index+1
+            };
+            _index += 1;
+          }
+        }
+        else if( "<>".indexOf(c1) >= 0) {
+          if((c2 == "=") || ("<>".indexOf(c2) >= 0 && c1 != c2)) {
+            _token = {
+              type: Exhibit.ExpressionScanner.OPERATOR,
+              value: c1 + c2,
+              start: _index,
+              end: _index + 2
+            };
+            _index += 2;
+          }
+          else {
+            _token = {
+              type: Exhibit.ExpressionScanner.OPERATOR,
+              value: c1,
+              start: _index,
+              end: _index+1
+            };
+            _index += 1;
+          }
+        }
+        else if( "+-*/=".indexOf(c1) >= 0) {
+          _token = {
+            type: Exhibit.ExpressionScanner.OPERATOR,
+            value: c1,
+            start: _index,
+            end: _index+1
+          };
+          _index += 1;
+        }
+        else if( "()".indexOf(c1) >= 0) {
+          _token = {
+            type: Exhibit.ExpressionScanner.DELIMITER,
+            value: c1,
+            start: _index,
+            end: _index+1
+          };
+          _index += 1;
+        }
+        else if( "\"'".indexOf(c1) >= 0) { // quoted strings
+          i = _index + 1;
+          while( i < _maxIndex ) {
+            if( _text.charAt(i) == c1 && _text.charAt(i-1) != "\\") {
+              break;
+            }
+            i += 1;
+          }
+
+          if(i < _maxIndex) {
+            _token = {
+              type: Exhibit.ExpressionScanner.STRING,
+              value: _text.substring(_index+1, i).replace(/\\'/g, "'").replace(/\\"/g, '"'),
+              start: _index,
+              end: i+1
+            };
+            _index = i + 1;
+          }
+          else {
+            throw new Error("Unterminated string starting at " + _index);
+          }
+        }
+        else if(isDigit(c1)) { // number
+          i = _index;
+          while( i < _maxIndex && isDigit(_text.charAt(i))) {
+            i += 1;
+          }
+
+          if( i < _maxIndex && _text.charAt(i) == "." ) {
+            i += 1;
+            while( i < _maxIndex && isDigit(_text.charAt(i))) {
+              i += 1;
+            }
+          }
+
+          _token = {
+            type: Exhibit.ExpressionScanner.NUMBER,
+            value: parseFloat(_text.substring(_index, i)),
+            start: _index,
+            end: i
+          };
+
+          _index = i;
+        }
+        else { // identifier
+          i = _index;
+
+          while( i < _maxIndex ) {
+            c = _text.charAt(i);
+            if( "(),.!@ \t".indexOf(c) < 0 ) {
+              i += 1;
+            }
+            else {
+              break;
+            }
+          }
+
+          _token = {
+            type: Exhibit.ExpressionScanner.IDENTIFIER,
+            value: _text.substring(_index, i),
+            start: _index,
+            end: i
+          };
+          _index = i;
+        }
+      }
+    };
+
+    that.next();
+
+    return that;
+  };
+
+  Exhibit.ExpressionScanner.DELIMITER     = 0;
+  Exhibit.ExpressionScanner.NUMBER        = 1;
+  Exhibit.ExpressionScanner.STRING        = 2;
+  Exhibit.ExpressionScanner.IDENTIFIER    = 3;
+  Exhibit.ExpressionScanner.OPERATOR      = 4;
+  Exhibit.ExpressionScanner.PATH_OPERATOR = 5;
+
+})(jQuery, Fabulator.Exhibit);