lsm/Orchard
1
0
Fork 0
mirror of https://github.com/OrchardCMS/Orchard.git synced 2025-10-15 19:54:57 +08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Bunch of renames and class re-organization

Browse Source 
--HG--
branch : dev
This commit is contained in:
Renaud Paquay
2010-11-27 17:49:20 -08:00
parent 19504f2d40
commit 847cf5fb66
8 changed files with 0 additions and 688 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/Orchard.Tests.Modules/SimpleScriptingTests/ExpressionEvaluatorTests.cs
View File

@@ -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();
}
}
}

76
src/Orchard.Tests.Modules/SimpleScriptingTests/ExpressionTokenizerTests.cs
View File

@@ -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));
}
}
}

17
src/Orchard.Tests.Modules/SimpleScriptingTests/SimpleScriptingTests.cs
View File

@@ -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);
}
}
}

44
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ExpressionLexer.cs
View File

@@ -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; }
}
}
}
}

170
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ExpressionParser.cs
View File

@@ -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);
}
}
}

225
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ExpressionTokenizer.cs
View File

@@ -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);
}
}
}
}

122
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ExpressionTree.cs
View File

@@ -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;
}
}
}
}
}

21
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/TokenKind.cs
View File

@@ -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
}
}