public void MergeTemplate(IViewSource viewSource, bool replaceCurrentNode)
{
var previous = CurrentNode.Previous;
var lineNumber = 0;
using (var reader = viewSource.GetStreamReader())
{
string line;
while ((line = reader.ReadLine()) != null)
{
//Swallow empty lines
if (line.Length == 0)
{
continue;
}
var inputLine = new InputLine(CurrentNode.Value.Indent + line, lineNumber++, options.IndentSize);
inputLines.AddBefore(CurrentNode, inputLine);
}
}
if (replaceCurrentNode)
{
inputLines.Remove(CurrentNode);
}
CurrentNode = previous.Next;
}
public TemplateFactory CompileTemplateFactory(string className, IViewSource viewSource)
{
var hamlDocument = _treeParser.ParseViewSource(viewSource);
string templateCode = _treeWalker.Walk(hamlDocument, className);
var templateFactory = _templateFactoryCompiler.Compile(templateCode, className, GetCompileTypes() );
return templateFactory;
}
public RubyView(string fileName, TextWriter output, IViewSource viewSource, ScriptRuntime scriptRuntime)
{
ViewSource = viewSource;
_fileName = fileName;
_output = output;
_scriptRuntime = scriptRuntime;
}
public RubyTemplateParser(IViewSource sourceLoader)
{
if (sourceLoader == null)
{
throw new ArgumentNullException("sourceLoader");
}
_sourceLoader = sourceLoader;
}
public static Task <List <T> > SimpleSearchRawAsync <V, T, E, S>(
this IViewSource <V, T, E, S> source, S search, Func <IQueryable <E>, IQueryable <E> > modify = null)
where V : IIdView where S : IIdSearcher where E : EntityGroup
{
var ids = source.SearchIds(search, modify);
return(source.RetrieveAsync(ids));
}
public TemplateFactory GetCompiledTemplate(IViewSource viewSource, Type templateBaseType)
{
Invariant.ArgumentNotNull(viewSource, "viewSource");
Invariant.ArgumentNotNull(templateBaseType, "templateBaseType");
templateBaseType = ProxyExtracter.GetNonProxiedType(templateBaseType);
return _compiledTemplateCache.GetOrAdd(viewSource, _templateFactoryFactory);
}
public HamlDocument ParseViewSource(IViewSource layoutViewSource)
{
HamlDocument result = null;
using (var streamReader = layoutViewSource.GetStreamReader())
{
result = ParseStreamReader(streamReader);
}
return result;
}
public static async Task <V> FindByIdAsync <V, T, E, S>(
this IViewSource <V, T, E, S> source, long id, Func <IQueryable <E>, IQueryable <E> > modify = null)
where V : IIdView where S : IIdSearcher, new() where E : EntityGroup
{
var search = new S();
search.Ids.Add(id);
return((await source.SimpleSearchAsync(search, modify)).OnlySingle());
}
/// <summary>
/// gets the named resource as a stream, parses and inits
/// </summary>
public override bool Process()
{
viewSource = ((ResourceLoaderAdapter) resourceLoader).GetViewSource(Name);
if (viewSource == null)
{
throw new ResourceNotFoundException("Resource could not be located: " + Name);
}
return base.Process();
}
/// <summary>
/// gets the named resource as a stream, parses and inits
/// </summary>
public override bool Process()
{
viewSource = ((ResourceLoaderAdapter)resourceLoader).GetViewSource(Name);
if (viewSource == null)
{
throw new ResourceNotFoundException("Resource could not be located: " + Name);
}
return(base.Process());
}
// create an input from a resource name
public ICompilerInput CreateInput(string name)
{
IViewSource viewSrc = ViewSourceLoader.GetViewSource(name);
if (viewSrc == null)
{
throw new Exception(string.Format("{0} is not a valid view", name));
}
// I need to do it this way because I can't tell
// when to dispose of the stream.
// It is not expected that this will be a big problem, the string
// will go away after the compile is done with them.
using (var stream = new StreamReader(viewSrc.OpenViewStream()))
{
return(new StringInput(name, stream.ReadToEnd()));
}
}
public TemplateFactory GetOrAdd(IViewSource viewSource,
ITemplateFactoryFactory factoryFactory)
{
TemplateFactory compiledTemplate;
var className = viewSource.GetClassName();
lock( _compiledTemplateCache )
{
if (!_compiledTemplateCache.TryGetValue(className, out compiledTemplate))
{
compiledTemplate = factoryFactory.CompileTemplateFactory(className, viewSource);
_compiledTemplateCache.Add(className, compiledTemplate);
return compiledTemplate;
}
}
return compiledTemplate;
}
public void Changing_View_Causes_Recompile()
{
SetupResult.For(_httpContext.Request.ApplicationPath).Return("/ApplicationPath");
_mocks.ReplayAll();
IViewSource viewSource = _viewEngine.ViewSourceLoader.GetViewSource("apppath.brail");
string originalSource;
using (TextReader reader = File.OpenText(viewSource.FullName))
{
originalSource = reader.ReadToEnd();
}
string expected = "Current apppath is /ApplicationPath/";
string actual = GetViewOutput("apppath");
Assert.AreEqual(expected, actual);
string newSource = "newSource";
using (TextWriter writer = File.CreateText(viewSource.FullName))
{
writer.Write(newSource);
}
Thread.Sleep(100);
//TODO: Clear output
_output.GetStringBuilder().Remove(0, _output.GetStringBuilder().Length);
//_httpContext.Response.ClearOutput();
actual = GetViewOutput("apppath");
try
{
Assert.AreEqual(newSource, actual);
}
finally
{
using (TextWriter writer = File.CreateText(viewSource.FullName))
{
writer.Write(originalSource);
}
}
}
private void ProcessViewSource(IViewSource viewSource)
{
viewSourceReader.MergeTemplate(viewSource, false);
while (viewSourceReader.CurrentNode.Next != null)
{
var rule = viewSourceReader.GetRule();
if (rule.PerformCloseActions)
{
CloseBlocks();
BlockClosingActions.Push(rule.Render(viewSourceReader, Options, builder));
viewSourceReader.MoveNext();
}
else
{
rule.Render(viewSourceReader, Options, builder);
}
}
CloseBlocks();
}
private void ProcessViewSource(IViewSource viewSource)
{
viewSourceReader.MergeTemplate(viewSource, false);
while (viewSourceReader.CurrentNode.Next != null)
{
var rule = viewSourceReader.GetRule();
if (rule.PerformCloseActions)
{
CloseBlocks();
BlockClosingActions.Push(rule.Render(viewSourceReader, Options, builder));
viewSourceReader.MoveNext();
}
else
{
rule.Render(viewSourceReader, Options, builder);
}
}
CloseBlocks();
}
public ViewFile(IViewSource source)
{
_source = source;
}
public BasePermissionViewService(ViewServicePack services, ILogger <BasePermissionViewService <V, S> > logger,
IViewSource <V, EntityPackage, EntityGroup, S> converter, BanViewSource banSource)
: base(services, logger, converter)
{
this.banSource = banSource;
}
public CompiledTemplate Compile(IViewSource template, IViewSource master, IViewSource defaultMaster, Type BaseType)
{
CompiledTemplate compiledMaster = null;
if (master != null)
compiledMaster = Compile(master, (IViewSource)null, null, null);
CompiledTemplate compiledDefaultMaster = null;
if (defaultMaster != null)
compiledDefaultMaster = Compile(defaultMaster, (IViewSource)null, null, null);
return Compile(template,compiledMaster, compiledDefaultMaster, null, BaseType);
}
public static async Task <List <V> > SimpleSearchAsync <V, T, E, S>(
this IViewSource <V, T, E, S> source, S search, Func <IQueryable <E>, IQueryable <E> > modify = null)
where V : IIdView where S : IIdSearcher where E : EntityGroup
{
return((await source.SimpleSearchRawAsync(search, modify)).Select(x => source.ToView(x)).ToList());
}
public TemplateFactory GetCompiledTemplate(IViewSource viewSource)
{
return GetCompiledTemplate(viewSource, typeof(TemplateBase.Template));
}
public ViewSourceWrapper(IViewSource source)
{
_source = source;
}
public void Dispose()
{
_sourceLoader = null;
}
public void MergeTemplate(IViewSource viewSource, bool replaceCurrentNode)
{
var previous = CurrentNode.Previous;
var lineNumber = 0;
using (var reader = viewSource.GetReader())
{
string line;
while ((line = reader.ReadLine()) != null)
{
//Swallow empty lines
if (line.Length == 0)
{
continue;
}
var inputLine = new InputLine(CurrentNode.Value.Indent + line, lineNumber++, options.IndentSize);
inputLines.AddBefore(CurrentNode, inputLine);
}
}
if (replaceCurrentNode)
{
inputLines.Remove(CurrentNode);
}
CurrentNode = previous.Next;
}
public CompiledTemplate Compile(IViewSource template, IViewSource master)
{
return Compile(template, master, null, null);
}
//public const int SpecialRetries = 5;
//public const int SpecialDelayMs = 1000;
public BaseEntityViewService(ViewServicePack services, ILogger <BaseEntityViewService <V, S> > logger, IViewSource <V, EntityPackage, EntityGroup, S> converter)
: base(services, logger)
{
this.converter = converter;
}
public ViewFile(IViewSource source)
{
_source = source;
}
public ViewSourceWrapper(IViewSource source)
{
_source = source;
}
public CompiledTemplate Compile(IViewSource template, CompiledTemplate master, CompiledTemplate defaultMaster, object context, Type BaseType)
{
Invariant.ArgumentNotNull( template, "template" );
var opts = (TemplateOptions)Options.Clone();
var origtype = opts.TemplateBaseType;
if (BaseType != null)
{
opts.TemplateBaseType = BaseType;
}
List<MetaNode> data;
if (template.ParseResult.Metadata.TryGetValue("assembly", out data))
{
foreach (var assemblyNode in data)
{
opts.AddReference(assemblyNode.Value);
}
}
if (template.ParseResult.Metadata.TryGetValue("namespace", out data))
{
foreach (var namespaceNode in data)
{
opts.AddUsing(namespaceNode.Value);
}
}
MetaNode pagedefiniton = MetaDataFiller.FillAndGetPageDefinition(template.ParseResult.Metadata, opts);
if (pagedefiniton.Attributes.Find(x => x.Name == "Inherits") != null)
{
string inherittype = ((TextChunk)((TextNode)pagedefiniton.Attributes.Find(x => x.Name == "Inherits").Value).Chunks[0]).Text;
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
var modelType = assembly.GetType(inherittype, false, true);
if (modelType != null)
{
opts.TemplateBaseType = ProxyExtractor.GetNonProxiedType(modelType);
}
}
}
if (template.ParseResult.Metadata.TryGetValue("type", out data))
{
if ((opts.TemplateBaseType.IsGenericTypeDefinition) || ((BaseType!= null) && (origtype.IsGenericTypeDefinition)))
{
string modeltypestring = data[0].Value;
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
var modelType = assembly.GetType(modeltypestring, false, true);
if (modelType != null)
{
if (opts.TemplateBaseType.IsGenericTypeDefinition)
{
opts.TemplateBaseType = opts.TemplateBaseType.MakeGenericType(ProxyExtractor.GetNonProxiedType(modelType));
break;
}
else if (origtype.IsGenericTypeDefinition)
{
opts.TemplateBaseType = origtype.MakeGenericType(ProxyExtractor.GetNonProxiedType(modelType));
break;
}
}
}
}
}
if (opts.TemplateBaseType.IsGenericTypeDefinition)
{
opts.TemplateBaseType = opts.TemplateBaseType.MakeGenericType(typeof(object));
}
// check if there is a default masterpagefile definition inside the content page.
// If yes, use that instead of the defaultTemplate
if (master == null)
{
AttributeNode masterNode = pagedefiniton.Attributes.Find(x => x.Name == "MasterPageFile");
if (masterNode != null)
{
string masterName = ((TextChunk)((TextNode)masterNode.Value).Chunks[0]).Text;
master = Compile(masterName);
}
else
{
if (defaultMaster != null)
{
master = defaultMaster;
}
}
}
var templateCacheKey = template.Path;
if (master != null) templateCacheKey = templateCacheKey + master.ContentFile.Path + opts.TemplateBaseType.FullName;
CompiledTemplate compiledTemplate;
lock( _compiledTemplateCache )
{
var key = templateCacheKey.ToString();
if( !_compiledTemplateCache.TryGetValue( key, out compiledTemplate ) )
{
compiledTemplate = new CompiledTemplate(opts, opts.TemplateBaseType, context, master, template);
_compiledTemplateCache.Add( key, compiledTemplate );
return compiledTemplate;
}
}
if( Options.AutoRecompile )
{
compiledTemplate.Recompile();
}
return compiledTemplate;
}
