Bunch of renames and class re-organization

--HG-- branch : dev
2026-02-09 09:16:41 +08:00 · 2010-11-27 17:49:20 -08:00
parent 19504f2d40
commit 847cf5fb66
8 changed files with 0 additions and 688 deletions
@@ -1,13 +0,0 @@
 using NUnit.Framework;
 using Orchard.Widgets.SimpleScripting;
 namespace Orchard.Tests.Modules.SimpleScriptingTests {
    [TestFixture]
    public class ExpressionEvaluatorTests {
        [Test]
        public void EvaluateSimpleConstant() {
            var tree = new ExpressionParser("1*2+3").Parse();
        }
    }
 }
@@ -1,76 +0,0 @@
 using NUnit.Framework;
 using Orchard.Widgets.SimpleScripting;
 namespace Orchard.Tests.Modules.SimpleScriptingTests {
    [TestFixture]
    public class ExpressionTokenizerTests {
        [Test]
        public void LexerShouldProcessSingleQuotedStringLiteral() {
            TestStringLiteral(@"'toto'", @"toto", TokenKind.SingleQuotedStringLiteral);
            TestStringLiteral(@"'to\'to'", @"to'to", TokenKind.SingleQuotedStringLiteral);
            TestStringLiteral(@"'to\\to'", @"to\to", TokenKind.SingleQuotedStringLiteral);
            TestStringLiteral(@"'to\ato'", @"to\ato", TokenKind.SingleQuotedStringLiteral);
        }
        [Test]
        public void LexerShouldProcessStringLiteral() {
            TestStringLiteral(@"""toto""", @"toto", TokenKind.StringLiteral);
            TestStringLiteral(@"""to\'to""", @"to'to", TokenKind.StringLiteral);
            TestStringLiteral(@"""to\\to""", @"to\to", TokenKind.StringLiteral);
            TestStringLiteral(@"""to\ato""", @"toato", TokenKind.StringLiteral);
        }
        private void TestStringLiteral(string value, string expected, TokenKind expectedTokenKind) {
            var lexer = new ExpressionTokenizer(value);
            var token1 = lexer.NextToken();
            Assert.That(token1.Kind, Is.EqualTo(expectedTokenKind));
            Assert.That(token1.Value, Is.EqualTo(expected));
            var token2 = lexer.NextToken();
            Assert.That(token2.Kind, Is.EqualTo(TokenKind.Eof));
        }
        [Test]
        public void LexerShouldProcessReservedWords() {
            TestReservedWord("true", true, TokenKind.True);
            TestReservedWord("false", false, TokenKind.False);
            TestReservedWord("not", null, TokenKind.Not);
            TestReservedWord("and", null, TokenKind.And);
            TestReservedWord("or", null, TokenKind.Or);
        }
        private void TestReservedWord(string expression, object value, TokenKind expectedTokenKind) {
            var lexer = new ExpressionTokenizer(expression);
            var token1 = lexer.NextToken();
            Assert.That(token1.Kind, Is.EqualTo(expectedTokenKind));
            Assert.That(token1.Value, Is.EqualTo(value));
            var token2 = lexer.NextToken();
            Assert.That(token2.Kind, Is.EqualTo(TokenKind.Eof));
        }
        [Test]
        public void LexerShouldProcesSequenceOfTokens() {
            CheckTokenSequence("true false", TokenKind.True, TokenKind.False);
            CheckTokenSequence("true toto false", TokenKind.True, TokenKind.Identifier, TokenKind.False);
        }
        [Test]
        public void LexerShouldProcesSequenceOfTokens2() {
            CheckTokenSequence("1+2*3", TokenKind.Integer, TokenKind.Plus, TokenKind.Integer, TokenKind.Mul, TokenKind.Integer);
        }
        private void CheckTokenSequence(string expression, params TokenKind[] tokenKinds) {
            var lexer = new ExpressionTokenizer(expression);
            foreach (var kind in tokenKinds) {
                var token = lexer.NextToken();
                Assert.That(token.Kind, Is.EqualTo(kind));
            }
            var token2 = lexer.NextToken();
            Assert.That(token2.Kind, Is.EqualTo(TokenKind.Eof));
        }
    }
 }
@@ -1,17 +0,0 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
 using Orchard.Tests.Stubs;
 using Orchard.Widgets.Services;
 using Orchard.Widgets.SimpleScripting;
 namespace Orchard.Tests.Modules.SimpleScriptingTests {
    [TestFixture]
    public class SimpleScriptingTests {
        [Test]
        public void EngineUnderstandsPrimitiveValues() {
            var engine = new ScriptingEngine(Enumerable.Empty<IRuleProvider>(), new StubCacheManager());
            Assert.That(engine.Matches("true"), Is.True);
        }
    }
 }
@@ -1,44 +0,0 @@
 using System.Collections.Generic;
 namespace Orchard.Widgets.SimpleScripting {
    public class ExpressionLexer {
        private readonly ExpressionTokenizer _tokenizer;
        private readonly List<ExpressionTokenizer.Token> _tokens= new List<ExpressionTokenizer.Token>();
        private int _tokenIndex;
        public ExpressionLexer(ExpressionTokenizer tokenizer) {
            _tokenizer = tokenizer;
        }
        public ExpressionTokenizer.Token Token() {
            if (_tokenIndex == _tokens.Count) {
                _tokens.Add(_tokenizer.NextToken());
            }
            return _tokens[_tokenIndex];
        }
        public void NextToken() {
            _tokenIndex++;
        }
        public Marker Mark() {
            return new Marker(_tokens.Count);
        }
        public void Mark(Marker marker) {
            _tokenIndex = marker.TokenIndex;
        }
        public struct Marker {
            private readonly int _tokenIndex;
            public Marker(int tokenIndex) {
                _tokenIndex = tokenIndex;
            }
            public int TokenIndex {
                get { return _tokenIndex; }
            }
        }
    }
 }
@@ -1,170 +0,0 @@
 using System;
 using System.Collections.Generic;
 namespace Orchard.Widgets.SimpleScripting {
    public class ExpressionParser {
        private readonly string _expression;
        private readonly ExpressionLexer _lexer;
        private readonly List<string> _errors = new List<string>();
        public ExpressionParser(string expression) {
            _expression = expression;
            _lexer = new ExpressionLexer(new ExpressionTokenizer(_expression));
        }
        public ExpressionTree Parse() {
            var node = ParseExpression();
            return new ExpressionTree { Root = node };
        }
        private ExpressionTree.Expression ParseExpression() {
            return ParseKeywordLogicalExpression();
        }
        private ExpressionTree.Expression ParseKeywordLogicalExpression() {
            return ParseKeywordOrExpression();
        }
        private ExpressionTree.Expression ParseKeywordOrExpression() {
            var expr = ParseKeywordAndExpression();
            var token = IsMatch(TokenKind.Or);
            if (token != null)
            {
                var right = ParseKeywordOrExpression();
                expr = new ExpressionTree.BinaryExpression(expr, token, right);
            }
            return expr;
        }
        private ExpressionTree.Expression ParseKeywordAndExpression() {
            var expr = ParseKeywordNotExpression();
            var token = IsMatch(TokenKind.And);
            if (token != null) {
                var right = ParseKeywordAndExpression();
                expr = new ExpressionTree.BinaryExpression(expr, token, right);
            }
            return expr;
        }
        private ExpressionTree.Expression ParseKeywordNotExpression() {
            var token = IsMatch(TokenKind.Not);
            if (token != null) {
                var expr = ParseKeywordNotExpression();
                return new ExpressionTree.UnaryExpression(expr, token);
            }
            return ParseRelationalExpression();
        }
        private ExpressionTree.Expression ParseRelationalExpression() {
            var expr = ParseAdditiveExpression();
            //TODO
            //var token = IsMatch(TokenKind.Not);
            //if (token != null) {
            return expr;
        }
        private ExpressionTree.Expression ParseAdditiveExpression() {
            var expr = ParseMultiplicativeExpression();
            var token = IsMatch(TokenKind.Plus, TokenKind.Minus);
            if (token != null) {
                var right = ParseAdditiveExpression();
                expr = new ExpressionTree.BinaryExpression(expr, token, right);
            }
            return expr;
        }
        private ExpressionTree.Expression ParseMultiplicativeExpression() {
            var expr = ParseUnaryExpression();
            var token = IsMatch(TokenKind.Mul, TokenKind.Div);
            if (token != null) {
                var right = ParseMultiplicativeExpression();
                expr = new ExpressionTree.BinaryExpression(expr, token, right);
            }
            return expr;
        }
        private ExpressionTree.Expression ParseUnaryExpression() {
            //TODO
            return ParsePrimaryExpression();
        }
        private ExpressionTree.Expression ParsePrimaryExpression() {
            var token = _lexer.Token();
            switch(_lexer.Token().Kind) {
                case TokenKind.True:
                case TokenKind.False:
                case TokenKind.SingleQuotedStringLiteral:
                case TokenKind.StringLiteral:
                case TokenKind.Integer:
                    return ProduceConstant(token);
                case TokenKind.OpenParen:
                    return ParseParenthesizedExpression();
                default:
                    return ProduceError(token);
            }
        }
        private ExpressionTree.Expression ProduceConstant(ExpressionTokenizer.Token token) {
            _lexer.NextToken();
            return new ExpressionTree.ConstantExpression(token);
        }
        private ExpressionTree.Expression ProduceError(ExpressionTokenizer.Token token) {
            _lexer.NextToken();
            return new ExpressionTree.ErrorExpression(token,
                                                      string.Format("Unexptected token in primary expression ({0})", token));
        }
        private ExpressionTree.Expression ParseParenthesizedExpression() {
            Match(TokenKind.OpenParen);
            var expr = ParseExpression();
            Match(TokenKind.CloseParen);
            return expr;
        }
        private void Match(TokenKind kind) {
            var token = _lexer.Token();
            if (token.Kind == kind) {
                _lexer.NextToken();
                return;
            }
            AddError(token, string.Format("Expected token {0}", kind));
        }
        private ExpressionTokenizer.Token IsMatch(TokenKind kind) {
            var token = _lexer.Token();
            if (token.Kind == kind) {
                _lexer.NextToken();
                return token;
            }
            return null;
        }
        private ExpressionTokenizer.Token IsMatch(TokenKind kind, TokenKind kind2) {
            var token = _lexer.Token();
            if (token.Kind == kind || token.Kind == kind2) {
                _lexer.NextToken();
                return token;
            }
            return null;
        }
        private void AddError(ExpressionTokenizer.Token token, string message) {
            _errors.Add(message);
        }
    }
 }
@@ -1,225 +0,0 @@
 using System;
 using System.Text;
 namespace Orchard.Widgets.SimpleScripting {
    public class ExpressionTokenizer {
        private readonly string _expression;
        private readonly StringBuilder _stringBuilder;
        private int _index;
        private int _startTokenIndex;
        public ExpressionTokenizer(string expression) {
            _expression = expression;
            _stringBuilder = new StringBuilder();
        }
        public Token NextToken() {
            if (Eof())
                return CreateToken(TokenKind.Eof);
        LexAgain:
            _startTokenIndex = _index;
            char ch = Character();
            switch (ch) {
                case '(':
                    NextCharacter();
                    return CreateToken(TokenKind.OpenParen);
                case ')':
                    NextCharacter();
                    return CreateToken(TokenKind.CloseParen);
                case '+':
                    NextCharacter();
                    return CreateToken(TokenKind.Plus);
                case '-':
                    NextCharacter();
                    return CreateToken(TokenKind.Minus);
                case '*':
                    NextCharacter();
                    return CreateToken(TokenKind.Mul);
                case '/':
                    NextCharacter();
                    return CreateToken(TokenKind.Div);
                case '"':
                    return LexStringLiteral();
                case '\'':
                    return LexSingleQuotedStringLiteral();
            }
            if (IsDigitCharacter(ch)) {
                return LexInteger();
            }
            else if (IsIdentifierCharacter(ch)) {
                return LexIdentifierOrKeyword();
            }
            else if (IsWhitespaceCharacter(ch)) {
                NextCharacter();
                goto LexAgain;
            }
            return CreateToken(TokenKind.Invalid, "Unrecognized character");
        }
        private Token LexIdentifierOrKeyword() {
            _stringBuilder.Clear();
            _stringBuilder.Append(Character());
            while (true) {
                NextCharacter();
                if (!Eof() && (IsIdentifierCharacter(Character()) || IsDigitCharacter(Character()))) {
                    _stringBuilder.Append(Character());
                }
                else {
                    return CreateIdentiferOrKeyword(_stringBuilder.ToString());
                }
            }
        }
        private Token LexInteger() {
            _stringBuilder.Clear();
            _stringBuilder.Append(Character());
            while (true) {
                NextCharacter();
                if (!Eof() && IsDigitCharacter(Character())) {
                    _stringBuilder.Append(Character());
                }
                else {
                    return CreateToken(TokenKind.Integer, Int32.Parse(_stringBuilder.ToString()));
                }
            }
        }
        private Token CreateIdentiferOrKeyword(string identifier) {
            switch (identifier) {
                case "true":
                    return CreateToken(TokenKind.True, true);
                case "false":
                    return CreateToken(TokenKind.False, false);
                case "or":
                    return CreateToken(TokenKind.Or, null);
                case "and":
                    return CreateToken(TokenKind.And, null);
                case "not":
                    return CreateToken(TokenKind.Not, null);
                default:
                    return CreateToken(TokenKind.Identifier, identifier);
            }
        }
        private bool IsWhitespaceCharacter(char character) {
            return char.IsWhiteSpace(character);
        }
        private bool IsIdentifierCharacter(char ch) {
            return
                (ch >= 'a' && ch <= 'z') ||
                (ch >= 'A' && ch <= 'Z') ||
                (ch == '_');
        }
        private bool IsDigitCharacter(char ch) {
            return ch >= '0' && ch <= '9';
        }
        private Token LexSingleQuotedStringLiteral() {
            _stringBuilder.Clear();
            while (true) {
                NextCharacter();
                if (Eof())
                    return CreateToken(TokenKind.Invalid, "Unterminated string literal");
                // Termination
                if (Character() == '\'') {
                    NextCharacter();
                    return CreateToken(TokenKind.SingleQuotedStringLiteral, _stringBuilder.ToString());
                }
                // backslash notation
                else if (Character() == '\\') {
                    NextCharacter();
                    if (Eof())
                        return CreateToken(TokenKind.Invalid, "Unterminated string literal");
                    if (Character() == '\\') {
                        _stringBuilder.Append('\\');
                    }
                    else if (Character() == '\'') {
                        _stringBuilder.Append('\'');
                    }
                    else {
                        _stringBuilder.Append('\\');
                        _stringBuilder.Append(Character());
                    }
                }
                // Regular character in string
                else {
                    _stringBuilder.Append(Character());
                }
            }
        }
        private Token LexStringLiteral() {
            _stringBuilder.Clear();
            while (true) {
                NextCharacter();
                if (Eof())
                    return CreateToken(TokenKind.Invalid, "Unterminated string literal");
                // Termination
                if (Character() == '"') {
                    NextCharacter();
                    return CreateToken(TokenKind.StringLiteral, _stringBuilder.ToString());
                }
                // backslash notation
                else if (Character() == '\\') {
                    NextCharacter();
                    if (Eof())
                        return CreateToken(TokenKind.Invalid, "Unterminated string literal");
                    _stringBuilder.Append(Character());
                }
                // Regular character in string
                else {
                    _stringBuilder.Append(Character());
                }
            }
        }
        private void NextCharacter() {
            _index++;
        }
        private char Character() {
            return _expression[_index];
        }
        private Token CreateToken(TokenKind kind, object value = null) {
            return new Token {
                Kind = kind,
                Position = _startTokenIndex,
                Value = value
            };
        }
        private bool Eof() {
            return (_index >= _expression.Length);
        }
        public class Token {
            public TokenKind Kind { get; set; }
            public int Position { get; set; }
            public object Value { get; set; }
            public override string ToString() {
                return string.Format("{0} ({1}) at position {2}", Kind, Value ?? "<noval>", Position);
            }
        }
    }
 }
@@ -1,122 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 namespace Orchard.Widgets.SimpleScripting {
    public class ExpressionTree {
        public Expression Root { get; set; }
        public interface IExpressionWithToken {
            ExpressionTokenizer.Token Token { get; }
        }
        public class Expression {
            public virtual IEnumerable<Expression> Children {
                get {
                    return Enumerable.Empty<Expression>();
                }
            }
            public override string ToString() {
                var sb = new StringBuilder();
                sb.Append(this.GetType().Name);
                var ewt = (this as IExpressionWithToken);
                if (ewt != null) {
                    sb.Append(" - ");
                    sb.Append(ewt.Token);
                }
                return sb.ToString();
            }
        }
        public class ErrorExpression : Expression, IExpressionWithToken {
            private readonly ExpressionTokenizer.Token _token;
            private readonly string _message;
            public ErrorExpression(ExpressionTokenizer.Token token, string message) {
                _token = token;
                _message = message;
            }
            public ExpressionTokenizer.Token Token {
                get { return _token; }
            }
            public string Message {
                get { return _message; }
            }
            public override string ToString() {
                return string.Format("{0} - {1}", GetType().Name, Message);
            }
        }
        public class ConstantExpression : Expression, IExpressionWithToken {
            private readonly ExpressionTokenizer.Token _token;
            public ConstantExpression(ExpressionTokenizer.Token token) {
                _token = token;
            }
            public ExpressionTokenizer.Token Token {
                get { return _token; }
            }
            public object Value { get { return _token.Value; } }
        }
        public class BinaryExpression : Expression, IExpressionWithToken {
            private readonly Expression _left;
            private readonly ExpressionTokenizer.Token _token;
            private readonly Expression _right;
            public BinaryExpression(Expression left, ExpressionTokenizer.Token token, Expression right) {
                _left = left;
                _token = token;
                _right = right;
            }
            public ExpressionTokenizer.Token Token {
                get { return _token; }
            }
            public ExpressionTokenizer.Token Operator {
                get { return _token; }
            }
            public override IEnumerable<Expression> Children {
                get {
                    yield return _left;
                    yield return _right;
                }
            }
        }
        public class UnaryExpression : Expression, IExpressionWithToken {
            private readonly Expression _expr;
            private readonly ExpressionTokenizer.Token _token;
            public UnaryExpression(Expression expr, ExpressionTokenizer.Token token) {
                _expr = expr;
                _token = token;
            }
            public ExpressionTokenizer.Token Token {
                get { return _token; }
            }
            public ExpressionTokenizer.Token Operator {
                get { return _token; }
            }
            public override IEnumerable<Expression> Children {
                get {
                    yield return _expr;
                }
            }
        }
    }
 }
@@ -1,21 +0,0 @@
 namespace Orchard.Widgets.SimpleScripting {
    public enum TokenKind {
        Eof,
        OpenParen,
        CloseParen,
        StringLiteral,
        SingleQuotedStringLiteral,
        Integer,
        Plus,
        Minus,
        Mul,
        Div,
        True,
        False,
        Identifier,
        And,
        Or,
        Not,
        Invalid
    }
 }