public override IList <Chunk> GetChunks(VisitorContext context, string path)
{
context.SyntaxProvider = this;
context.ViewPath = path;
SourceContext sourceContext = CreateSourceContext(context.ViewPath, context.ViewFolder);
var position = new Position(sourceContext);
ParseResult <IList <Node> > result = _grammar.Nodes(position);
if (result.Rest.PotentialLength() != 0)
{
ThrowParseException(context.ViewPath, position, result.Rest);
}
context.Paint = result.Rest.GetPaint();
IList <Node> nodes = result.Value;
foreach (INodeVisitor visitor in BuildNodeVisitors(context))
{
visitor.Accept(nodes);
nodes = visitor.Nodes;
}
var chunkBuilder = new ChunkBuilderVisitor(context);
chunkBuilder.Accept(nodes);
return(chunkBuilder.Chunks);
}
private void LoadInternal(string viewPath)
{
if (!string.IsNullOrEmpty(viewPath))
{
Entry entry = this.BindEntry(viewPath);
VisitorContext context = new VisitorContext {
ViewFolder = this.ViewFolder,
Prefix = this.Prefix,
ExtensionFactory = this.ExtensionFactory,
PartialFileNames = this.FindPartialFiles(viewPath),
Bindings = this.FindBindings(viewPath),
ParseSectionTagAsSegment = this.ParseSectionTagAsSegment,
AttributeBehaviour = this.AttributeBehaviour
};
entry.Chunks = this.SyntaxProvider.GetChunks(context, viewPath);
FileReferenceVisitor visitor = new FileReferenceVisitor();
visitor.Accept(entry.Chunks);
foreach (RenderPartialChunk chunk in visitor.References)
{
string str = this.ResolveReference(viewPath, chunk.Name);
if (!string.IsNullOrEmpty(str))
{
chunk.FileContext = this.BindEntry(str).FileContext;
}
}
}
}
private void LoadInternal(string viewPath)
{
if (string.IsNullOrEmpty(viewPath))
{
return;
}
var newEntry = this.BindEntry(viewPath);
var context = new VisitorContext
{
ViewFolder = this.ViewFolder,
Prefix = this.Prefix,
ExtensionFactory = this.ExtensionFactory,
PartialFileNames = this.FindPartialFiles(viewPath),
Bindings = this.FindBindings()
};
newEntry.Chunks = this.SyntaxProvider.GetChunks(context, viewPath);
var fileReferenceVisitor = new FileReferenceVisitor();
fileReferenceVisitor.Accept(newEntry.Chunks);
foreach (var useFile in fileReferenceVisitor.References)
{
var referencePath = this.ResolveReference(viewPath, useFile.Name);
if (!string.IsNullOrEmpty(referencePath))
{
useFile.FileContext = this.BindEntry(referencePath).FileContext;
}
}
}
public void Visit(ref VisitorContext context)
{
// Record reference of the instance being visited
var nodeBuilder = (DataVisitNodeBuilder)context.Visitor;
if (level == lastLevelVisit)
{
level++;
context.Visitor.VisitObject(context.Instance, context.Descriptor, true);
level--;
}
else if (recordReferences)
{
// Save Entity reference
var entity = context.Instance as Entity;
var entityComponent = context.Instance as EntityComponent;
Guid?id = entity?.Id ?? entityComponent?.Entity.Id;
if (id.HasValue)
{
List <DataVisitNode> nodes;
if (!References.TryGetValue(id.Value, out nodes))
{
nodes = new List <DataVisitNode>();
References.Add(id.Value, nodes);
}
nodes.Add(nodeBuilder.CurrentNode);
}
}
}
public void FindLoopParameters()
{
var context = new VisitorContext
{
SyntaxProvider = new DefaultSyntaxProvider(new SparkSettings())
};
var nodes = ParseNodes("<for each='var x in new [] {1,2,3}'>${xIndex}${xIsLast}</for>",
new SpecialNodeVisitor(context));
var visitor = new ChunkBuilderVisitor(context);
visitor.Accept(nodes);
var expressionVisitor = new DetectCodeExpressionVisitor(null);
var index = expressionVisitor.Add("xIndex");
var count = expressionVisitor.Add("xCount");
var isFirst = expressionVisitor.Add("xIsFirst");
var isLast = expressionVisitor.Add("xIsLast");
expressionVisitor.Accept(visitor.Chunks);
Assert.IsTrue(index.Detected);
Assert.IsFalse(count.Detected);
Assert.IsFalse(isFirst.Detected);
Assert.IsTrue(isLast.Detected);
}
public override IList <Chunk> GetChunks(VisitorContext context, string path)
{
context.SyntaxProvider = this;
context.ViewPath = path;
var sourceContext = CreateSourceContext(context.ViewPath, context.ViewFolder);
var position = new Position(sourceContext);
var isShadeExtension = string.Equals(Path.GetExtension(path), Constants.DotShade, StringComparison.OrdinalIgnoreCase);
var parser = (isShadeExtension ? _grammar.OffsetNodes : _grammar.Nodes);
var result = parser(position);
if (result.Rest.PotentialLength() != 0)
{
ThrowParseException(context.ViewPath, position, result.Rest);
}
context.Paint = result.Rest.GetPaint();
var nodes = result.Value;
foreach (var visitor in BuildNodeVisitors(context))
{
visitor.Accept(nodes);
nodes = visitor.Nodes;
}
var chunkBuilder = new ChunkBuilderVisitor(context);
chunkBuilder.Accept(nodes);
return(chunkBuilder.Chunks);
}
protected override void EndVisit(INode node)
{
if (node is PropertyGetRegion || node is PropertySetRegion) {
this.currentContext = VisitorContext.Default;
}
base.EndVisit(node);
}
public override IList <Chunk> GetChunks(VisitorContext context, string path)
{
context.SyntaxProvider = this;
context.ViewPath = path;
Position position = new Position(AbstractSyntaxProvider.CreateSourceContext(context.ViewPath, context.ViewFolder));
ParseAction <IList <Node> > action = string.Equals(Path.GetExtension(path), Constants.DotShade, StringComparison.OrdinalIgnoreCase) ? this._grammar.OffsetNodes : this._grammar.Nodes;
ParseResult <IList <Node> > result = action(position);
if (result.Rest.PotentialLength() != 0)
{
base.ThrowParseException(context.ViewPath, position, result.Rest);
}
context.Paint = result.Rest.GetPaint();
IList <Node> nodes = result.Value;
foreach (INodeVisitor visitor in this.BuildNodeVisitors(context))
{
visitor.Accept(nodes);
nodes = visitor.Nodes;
}
ChunkBuilderVisitor visitor2 = new ChunkBuilderVisitor(context);
visitor2.Accept(nodes);
return(visitor2.Chunks);
}
public static IList <Chunk> ParseElementChunks(string content, int position)
{
var node = ParseNode(content, position);
var contentToParse = node is ElementNode?GetElementNodeAsString((ElementNode)node) : content;
var grammar = new MarkupGrammar();
var visitorContext = new VisitorContext {
SyntaxProvider = new DefaultSyntaxProvider(new ParserSettings())
};
var result = grammar.Nodes(Source(contentToParse));
var nodes = result.Value;
foreach (var visitor in BuildChunkVisitors(visitorContext))
{
visitor.Accept(nodes);
nodes = visitor.Nodes;
}
var chunkBuilder = new ChunkBuilderVisitor(visitorContext);
chunkBuilder.Accept(nodes);
var chunks = chunkBuilder.Chunks;
return(chunks);
}
protected virtual string GetMemberName(Expression memberExpression, VisitorContext context)
{
var evaluator = new NameEvaluator(context);
evaluator.Visit(memberExpression);
return(evaluator.PropertyName);
}
public void Init()
{
_bindings = new List <Binding>();
_context = new VisitorContext {
Bindings = _bindings
};
_visitor = new BindingExpansionVisitor(_context);
}
protected override void EndVisit(INode node)
{
if (node is PropertyGetRegion || node is PropertySetRegion)
{
this.currentContext = VisitorContext.Default;
}
base.EndVisit(node);
}
public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
{
if (node.Name == "unittest")
{
return(new TestExtension());
}
return(null);
}
public void CanParseSimpleFile()
{
var context = new VisitorContext {
ViewFolder = new FileSystemViewFolder("Spark.Tests.Views")
};
var result = _syntax.GetChunks(context, Path.Combine("Home", "childview.spark"));
Assert.IsNotNull(result);
}
protected override void BeginVisit(INode node)
{
base.BeginVisit(node);
if (node is PropertyGetRegion) {
this.currentContext = VisitorContext.PropertyGetRegion;
} else if (node is PropertySetRegion) {
this.currentContext = VisitorContext.PropertySetRegion;
}
}
public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
{
IEnumerable <IReplacement> replacements = GetApplicableReplacements(node);
if (replacements.Any())
{
return(new SparkExtension(node, replacements));
}
return(null);
}
public TargetExtension(VisitorContext context, ElementNode targetElement, int targetExtensionCount)
{
_context = context;
_targetElement = targetElement;
_targetExtensionCount = targetExtensionCount;
_idAttribute = _targetElement.Attributes.SingleOrDefault(attr => attr.Name == "id");
_classAttribute = _targetElement.Attributes.SingleOrDefault(attr => attr.Name == "class");
_descriptionAttribute = _targetElement.Attributes.SingleOrDefault(attr => attr.Name == "description");
_targetAttribute = _targetElement.Attributes.SingleOrDefault(attr => attr.Name == "target");
}
protected void GivenSomeContentToCompile(string content)
{
_syntaxProvider = new CompletionSyntaxProvider();
_context = new VisitorContext
{
ViewFolder = new InMemoryViewFolder {
{ "Home\\index.spark", @"<div>${user.</div>" }
}
};
}
public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
{
ISparkElementTransformer elementTransformer = _sparkElementTransformerService.CreateElementTransformer(node);
if (elementTransformer is NullSparkElementTransformer)
{
return(null);
}
return(new SparkOverrideExtension(node, elementTransformer));
}
public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
{
IEnumerable<IReplacement> replacements = GetApplicableReplacements(node);
if (replacements.Any())
{
return new SparkExtension(node, replacements);
}
return null;
}
public override void Handle(UnaryExpression expression, VisitorContext context)
{
context.Visit(expression.Operand);
var val = context.GetResult();
var result = new QueryObject();
result.Add("$not", val);
context.SetResult(result);
}
public void TestVisitor()
{
var context = new VisitorContext();
var concreteElementOne = new ConcreteElementOne();
var visitor = new ConcreteVisitor();
context.AddElement(concreteElementOne);
context.Accept(visitor);
}
protected override void BeginVisit(INode node)
{
base.BeginVisit(node);
if (node is PropertyGetRegion)
{
this.currentContext = VisitorContext.PropertyGetRegion;
}
else if (node is PropertySetRegion)
{
this.currentContext = VisitorContext.PropertySetRegion;
}
}
public override void Handle(MethodCallExpression expression, VisitorContext context)
{
context.Visit(expression.Arguments[1]);
var matchCriteria = context.GetResult();
var regex = new QueryObject {
{ "$elemMatch", matchCriteria }
};
var query = CreateQuery(expression.Arguments[0], regex, context);
context.SetResult(query);
}
public static CodeThrowExceptionStatement @throw(Expression <Action> exp)
{
VisitorContext ctx = new VisitorContext();
ctx.VisitParams(exp.Parameters);
NewExpression newExp = new QueryVisitor((e) => e is NewExpression).Visit(exp) as NewExpression;
return(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(
new CodeTypeReference(newExp.Type),
new CodeExpressionVisitor(ctx).VisitExpressionList(newExp.Arguments).ToArray()
)));
}
public ISparkExtension CreateExtension(VisitorContext context, ElementNode node)
{
if (string.Equals(node.Name, "div", StringComparison.OrdinalIgnoreCase))
{
return(new TargetExtension(context, node, ++_TargetExtensionCount));
}
if (string.Equals(node.Name, "functions", StringComparison.OrdinalIgnoreCase))
{
return(new FunctionsExtension(context, node));
}
return(null);
}
public override void Handle(MethodCallExpression expression, VisitorContext context)
{
var list = (IEnumerable)((ConstantExpression)(expression.Arguments[0])).Value;
var binaryExp = (BinaryExpression)((LambdaExpression)expression.Arguments[1]).Body;
var property = binaryExp.Right as MemberExpression ?? (MemberExpression)binaryExp.Left;
var inQuery = new QueryObject {
{ "$in", list }
};
var query = CreateQuery(property, inQuery, context);
context.SetResult(query);
}
public void Visit(ref VisitorContext context)
{
var contextToken = PrepareLocalContext(context.Descriptor.Type);
try
{
context.Visitor.VisitObject(context.Instance, context.Descriptor, !LocalContext.Value.SerializeAsReference);
}
finally
{
CleanLocalContext(contextToken);
}
}
public void Visit(ref VisitorContext context)
{
var contextToken = PrepareLocalContext(context.Descriptor.Type);
try
{
context.Visitor.VisitObject(context.Instance, context.Descriptor, true);
}
finally
{
CleanLocalContext(contextToken);
}
}
public override IList <Node> IncludeFile(VisitorContext context, string path, string parse)
{
var existingPath = context.ViewPath;
var directoryPath = Path.GetDirectoryName(context.ViewPath);
var relativePath = path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
while (relativePath.StartsWith(string.Format("..{0}", Path.DirectorySeparatorChar)))
{
directoryPath = Path.GetDirectoryName(directoryPath);
relativePath = relativePath.Substring(3);
}
context.ViewPath = Path.Combine(directoryPath, relativePath);
var sourceContext = CreateSourceContext(context.ViewPath, context.ViewFolder);
switch (parse)
{
case "text":
var encoded = sourceContext.Content
.Replace("&", "&")
.Replace("<", "<")
.Replace(">", ">");
return(new[] { new TextNode(encoded) });
case "html":
return(new[] { new TextNode(sourceContext.Content) });
}
var position = new Position(sourceContext);
var result = _grammar.Nodes(position);
if (result.Rest.PotentialLength() != 0)
{
ThrowParseException(context.ViewPath, position, result.Rest);
}
context.Paint = context.Paint.Union(result.Rest.GetPaint());
var namespaceVisitor = new NamespaceVisitor(context);
namespaceVisitor.Accept(result.Value);
var includeVisitor = new IncludeVisitor(context);
includeVisitor.Accept(namespaceVisitor.Nodes);
context.ViewPath = existingPath;
return(includeVisitor.Nodes);
}
public override void Handle(BinaryExpression expression, VisitorContext context)
{
var nameValue = GetNameValue(expression);
var @operator = expression.NodeType == ExpressionType.Equal
? "$eq"
: "$ne";
var equal = new QueryObject {
{ @operator, nameValue.Constant.Value }
};
var result = CreateQuery(nameValue.Member, equal, context);
context.SetResult(result);
}
public override void Handle(MethodCallExpression expression, VisitorContext context)
{
var cValue = expression.Arguments[0] as ConstantExpression;
if (cValue == null)
{
throw new NotSupportedException("requires a parameter");
}
//var query = new QueryObject { { $"{name}.{cValue.Value.ToString()}", null } };
var query = CreateQuery(expression, null, context);
context.SetResult(query);
}
public override void Handle(UnaryExpression expression, VisitorContext context)
{
var memberExpression = (MemberExpression)((LambdaExpression)expression.Operand).Body;
var name = memberExpression.Member.Name;
var equal = new QueryObject {
{ "$eq", true }
};
var result = new QueryObject {
{ name, equal }
};
context.SetResult(result);
}
