1 files changed, 346 insertions, 0 deletions

diff --git a/node_modules/montage/core/selector/property-language.js b/node_modules/montage/core/selector/property-language.js
new file mode 100644
index 00000000..8269572c
--- /dev/null
+++ b/node_modules/montage/core/selector/property-language.js
@@ -0,0 +1,346 @@
+/* <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 AbstractLanguage = require('./abstract-language').AbstractLanguage;
+var Parser = require('./parser').Parser;
+var Semantics = require('./semantics').Semantics;
+var LANGUAGE = require('./language'); // late bound for dependency cycle
+
+var VALUE = 'value';
+var LITERAL = 'literal';
+var GET = 'get';
+var BEGIN = 'begin';
+var END = 'end';
+var MAP = 'map';
+var COMMA = 'comma';
+var IT = 'it';
+var DOT = '.';
+var ARRAY = 'array';
+var SORTED = 'sorted';
+
+var PropertyLanguage = exports.PropertyLanguage = AbstractLanguage.create(AbstractLanguage, {
+
+    semantics: {
+        value: Semantics
+    },
+
+    stringToToken: {
+        value: {
+            '(': {type: BEGIN},
+            ')': {type: END},
+            '*': {type: MAP},
+            ',': {type: COMMA}
+        }
+    },
+
+    tokenRe: {
+        value: /\(|\)|\d+|\w[\w\d]*|,|\*|\.|./g
+    },
+
+    termStartRe: {
+        value: /[\(\w\d\*]/
+    },
+
+    separatorsRe: {
+        value: /[\(\)\.,]/
+    },
+
+    tokenize: {
+        value: function (string, emit) {
+            var tokens;
+            if (!emit) {
+                tokens = [];
+                emit = function (token) {
+                    tokens.push(token);
+                }
+            }
+            var self = this;
+            var expectSeparator = false;
+            var expectTermStart = true;
+            var soFar = '';
+            string.replace(self.tokenRe, function (token) {
+                if (expectSeparator) {
+                    if (!self.separatorsRe.test(token)) {
+                        throw new Error(
+                            'Expected punctuation after: ' +
+                            JSON.stringify(soFar) + ", got: " +
+                            JSON.stringify(string.slice(soFar.length))
+                        );
+                    }
+                    expectSeparator = false;
+                }
+                if (expectTermStart) {
+                    if (!self.termStartRe.test(token)) {
+                        throw new Error(
+                            'Expected term after: ' + JSON.stringify(soFar) + ", got: " +
+                            JSON.stringify(string.slice(soFar.length))
+                        );
+                    }
+                }
+                if (token === DOT) {
+                    // ignore, used only for delimiting tokens, like a space
+                    expectTermStart = true;
+                } else if (self.stringToToken[token]) {
+                    emit(self.stringToToken[token]);
+                    expectTermStart = false;
+                } else if (/^\d+$/.test(token)) {
+                    emit({
+                        type: LITERAL,
+                        value: +token
+                    });
+                    expectSeparator = true;
+                    expectTermStart = false;
+                } else if (/^\w[\w\d]*$/.test(token)) {
+                    emit({
+                        type: LITERAL,
+                        value: token
+                    });
+                    expectSeparator = true;
+                    expectTermStart = false;
+                } else {
+                    throw new Error('Unexpected character: ' + JSON.stringify(token));
+                }
+                soFar += token;
+            })
+            return tokens;
+        }
+    },
+
+    parse: {
+        value: function (string) {
+            var self = this;
+            var syntax;
+            var parser = Parser.newWithLanguage(self, function (_syntax) {
+                syntax = _syntax;
+            });
+            self.tokenize(string, function (token) {
+                parser.emit(token);
+            })
+            parser.emit(LANGUAGE.Language.tokens.eof);
+            return syntax;
+        }
+    },
+
+    grammar: {
+        value: function () {
+            var self = this;
+
+            self.primary = self.parsePrimary(function (callback) {
+                return self.parseExpression(callback);
+            });
+
+            var parseTuple = self.parseTuple();
+
+            self.parseExpression = self.precedence();
+
+        }
+    },
+
+    parseTerm: {
+        value: function (consequent, alternate) {
+            var self = this;
+            return function (token) {
+                if (token.type === LITERAL) {
+                    return self.optional(BEGIN, function (begin) {
+                        if (begin) {
+                            return self.primary(function (expression) {
+                                return self.expect(END, function () {
+                                    return consequent({
+                                        call: true,
+                                        type: token.value,
+                                        arg: expression
+                                    });
+                                });
+                            });
+                        } else {
+                            return consequent({
+                                type: GET,
+                                arg: token
+                            });
+                        }
+                    });
+                } else if (token.type === MAP) {
+                    return self.parseTerm(function (map) {
+                        return consequent({
+                            type: MAP,
+                            arg: {
+                                type: map.type,
+                                args: [
+                                    {type: VALUE},
+                                    map.arg
+                                ]
+                            }
+                        })
+                    }, function () {
+                        return consequent({
+                            type: IT,
+                            arg: {type: VALUE}
+                        })
+                    });
+                } else if (token.type === BEGIN) {
+                    return self.parseExpression(function (expression) {
+                        return self.expect(END, function () {
+                            return consequent({
+                                type: IT,
+                                arg: expression
+                            });
+                        });
+                    });
+                } else {
+                    return alternate()(token);
+                }
+            };
+        }
+    },
+
+    parsePrimary: {
+        value: function (parseExpression) {
+            var self = this;
+            var parseSelf = self.precedence(function (parsePrevious) {
+                return function (callback, previous) {
+                    previous = previous || {type: VALUE};
+                    return self.parseTerm(function (term) {
+                        var syntax;
+                        if (term.call) {
+                            if (term.arg.type !== VALUE) {
+                                previous = {
+                                    type: MAP,
+                                    args: [
+                                        previous,
+                                        term.arg
+                                    ]
+                                };
+                            }
+                            syntax = {
+                                type: term.type,