1 files changed, 392 insertions, 0 deletions

diff --git a/node_modules/montage/core/selector/semantics.js b/node_modules/montage/core/selector/semantics.js
new file mode 100644
index 00000000..49446e2c
--- /dev/null
+++ b/node_modules/montage/core/selector/semantics.js
@@ -0,0 +1,392 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+var AbstractSemantics = require("./abstract-semantics").AbstractSemantics;
+
+var empty = {}; // used for getting properties of falsy objects
+
+var Semantics = exports.Semantics = AbstractSemantics.create(AbstractSemantics, {
+
+    operators: {
+        value: {
+
+            // from highest to lowest precedence
+
+            // unary
+            not: function (a) {
+                return !a;
+            },
+
+            // function calls
+            startsWith: function (a, b) {
+                return a.length >= b.length &&
+                    this.equals(a.slice(0, b.length), b);
+            },
+            endsWith: function (a, b) {
+                return a.length >= b.length &&
+                    this.equals(a.slice(a.length - b.length, a.length), b);
+            },
+
+            // algebra
+
+            // exponential
+            pow: function (a, b) {
+                return Math.pow(a, b);
+            },
+
+            // multiplicative
+            mul: function (a, b) {
+                return a * b;
+            },
+            div: function (a, b) {
+                return a / b;
+            },
+            mod: function (a, b) {
+                return a % b;
+            },
+
+            // arithmetic
+            add: function (a, b) {
+                return a + b;
+            },
+            sub: function (a, b) {
+                return a - b;
+            },
+
+            // transitive relations
+            lessThan: function (a, b) {
+                return Semantics.compare(a, b) < 0;
+            },
+            lessThanOrEquals: function (a, b) {
+                return Semantics.compare(a, b) <= 0;
+            },
+            greaterThan: function (a, b) {
+                return Semantics.compare(a, b) > 0;
+            },
+            greaterThanOrEquals: function (a, b) {
+                return Semantics.compare(a, b) >= 0;
+            },
+
+            // equivalence relations
+            equals: function (a, b) {
+                if (a == null || b == null) {
+                    return a === b;
+                } else if (a.equals) {
+                    return a.equals(b);
+                } else if (b.equals) {
+                    return b.equals(a);
+                } else {
+                    return a === b;
+                }
+            },
+            notEquals: function (a, b) {
+                return !this.equals(a, b);
+            },
+
+            // logical ('and' and 'or' are evaluators for the short-circuiting)
+
+            xor: function (a, b) {
+                return a !== b;
+            },
+
+            // collection operators
+
+            contains: function (collection, value) { // pertains to strings
+                return collection.indexOf(value) !== -1;
+            },
+            has: function (collection, value) { // pertains to other collections
+                return collection.indexOf(value) !== -1;
+            },
+
+            slice: function (collection, start, stop) {
+                return collection.slice(start, stop);
+            },
+            // TODO rewrite to accept length then from value
+            sliceFrom: function (collection, value, length) {
+                var start = collection.indexOf(value);
+                if (start !== -1) {
+                    length = Math.min(collection.length - start, length);
+                    return collection.slice(start, start + length);
+                } else {
+                    return [];
+                }
+            }
+
+        }
+    },
+
+    evaluators: {
+        value: {
+
+            // properties
+            get: function (evaluateObject, evaluateKey, parents) {
+
+                // construct remaining path
+                var remainingPath = [];
+                parents = parents.parents;
+                while (parents) {
+                    if (parents.syntax.type !== 'get')
+                        break;
+                    remainingPath.push(parents.syntax.args[1].value);
+                    parents = parents.parents;
+                }
+                if (remainingPath.length === 0) {
+                    remainingPath = null;
+                } else {
+                    remainingPath = remainingPath.join(".");
+                }
+
+                return function (value, parameters, visitor) {
+                    var object = evaluateObject(value, parameters, visitor);
+                    var key = evaluateKey(value, parameters, visitor);
+                    var result = (object || empty)[key];
+                    if (visitor) {
+                        visitor(object, key, result, remainingPath);
+                    }
+                    return result;
+                };
+            },
+
+            // logical
+            and: function (a, b) {
+                return function (value, parameters) {
+                    return a(value, parameters) && b(value, parameters);
+                };
+            },
+            or: function (a, b) {
+                return function (value, parameters) {
+                    return a(value, parameters) || b(value, parameters);
+                };
+            },
+
+            // ternary conditional
+            'if': function (guard, consequent, alternate) {
+                return function (value, parameters) {
+                    var flag = guard(value, parameters);
+                    if (flag === true) {
+                        return consequent(value, parameters);
+                    } else if (flag === false) {
+                        return alternate(value, parameters);
+                    } else {
+                        throw new Error("Expected true or false, got: " + JSON.stringify(flag));
+                    }
+                };
+            },
+
+            it: function (a, b) {
+                return function (value, parameters) {
+                    return b(a(value, parameters), parameters);
+                }
+            },
+
+            one: function (a, b) {
+                return function (value, parameters) {
+                    var object = a(value, parameters)[0]; // handle other collections
+                    return b(object, parameters);
+                };
+            },
+            only: function (a, b) {
+                return function (value, parameters) {
+                    var objects = a(value, parameters); // handle other collections
+                    if (objects.length !== 1)
+                        return false;
+                    return b(objects[0], parameters);
+                };
+            },
+            filter: function (a, b) {
+                return function (value, parameters) {
+                    return a(value, parameters)
+                    .filter(function (object) {
+                        return b(object, parameters);
+                    });
+                };
+            },
+            every: function (a, b) {
+                return function (value, parameters) {
+                    return a(value, parameters)
+                    .every(function (object) {
+                        return b(object, parameters);
+                    });
+                };
+            },
+            some: function (a, b) {
+                return function (value, parameters) {
+                    return a(value, parameters)
+                    .some(function (object) {
+                        return b(object, parameters);
+                    });
+                };
+            },
+            map: function (a, b) {
+                return function (value, parameters) {
+