public void VsTextViewCreated(IVsTextView textViewAdapter)
{
var textView = EditorAdaptersFactoryService.GetWpfTextView(textViewAdapter);
var contentType = textView.TextBuffer.ContentType;
ITextDocument document;
if (!TextDocumentFactoryService.TryGetTextDocument(textView.TextDataModel.DocumentBuffer, out document))
{
return;
}
var settings = WESettings.Instance.ForContentType <IChainableCompilerSettings>(contentType);
var notifierProvider = Mef.GetImport <ICompilationNotifierProvider>(contentType);
if (notifierProvider == null)
{
return;
}
var notifier = notifierProvider.GetCompilationNotifier(document);
var compilerProvider = Mef.GetImport <ICompilerRunnerProvider>(contentType);
if (compilerProvider == null)
{
return;
}
var compilerRunner = compilerProvider.GetCompiler(contentType);
var graph = GetGraph(contentType);
notifier.CompilationReady += async(s, e) =>
{
if (!e.CompilerResult.IsSuccess)
{
return;
}
if (!settings.CompileOnSave || !settings.EnableChainCompilation || (bool)s)
{
return;
}
var count = 0;
foreach (var file in await graph.GetRecursiveDependentsAsync(e.CompilerResult.SourceFileName))
{
if (File.Exists(compilerRunner.GetTargetPath(file)))
{
compilerRunner.CompileToDefaultOutputAsync(file).DoNotWait("compiling " + file);
count++;
}
}
WebEssentialsPackage.DTE.StatusBar.Text = "Compiling " + count + " dependent file" + (count == 1 ? "s" : "")
+ " for " + Path.GetFileName(e.CompilerResult.SourceFileName);
};
}
private void AddHtmlFiles()
{
var paths = ProjectHelpers.GetSelectedItemPaths(_dte);
var contentType = ContentTypeManager.GetContentType("Markdown");
var compiler = Mef.GetImport <ICompilerRunnerProvider>(contentType).GetCompiler(contentType);
Parallel.ForEach(paths, f => compiler.CompileToDefaultOutputAsync(f).DoNotWait("compiling " + f));
}
private void PopulateLanguageBuffer(IContentType contentType, IEnumerable <CodeLineArtifact> artifacts)
{
var pBuffer = ProjectionBufferManager.GetProjectionBuffer(contentType);
var embedder = Mef.GetImport <ICodeLanguageEmbedder>(contentType);
var fullSource = new StringBuilder();
if (embedder != null)
{
fullSource.AppendLine(embedder.GlobalPrefix);
}
var mappings = new List <ProjectionMapping>();
foreach (var block in artifacts.GroupBy(a => a.BlockInfo))
{
IReadOnlyCollection <string> surround = null;
if (embedder != null)
{
surround = embedder.GetBlockWrapper(block.Select(a => a.GetText(EditorTree.TextSnapshot)));
}
if (surround != null)
{
fullSource.AppendLine(surround.FirstOrDefault());
}
foreach (var artifact in block)
{
if (artifact.Start >= EditorTree.TextSnapshot.Length || artifact.End > EditorTree.TextSnapshot.Length || artifact.TreatAs != ArtifactTreatAs.Code)
{
continue;
}
mappings.Add(new ProjectionMapping(artifact.InnerRange.Start, fullSource.Length, artifact.InnerRange.Length, AdditionalContentInclusion.All));
fullSource.AppendLine(artifact.GetText(EditorTree.TextSnapshot));
}
if (surround != null)
{
fullSource.AppendLine(surround.LastOrDefault());
}
}
if (embedder != null)
{
fullSource.AppendLine(embedder.GlobalSuffix);
}
pBuffer.SetTextAndMappings(fullSource.ToString(), mappings.ToArray());
if (createdContentTypes.Add(contentType))
{
if (embedder != null)
{
embedder.OnBlockCreated(EditorTree.TextBuffer, pBuffer);
}
}
}
private async static Task MinifyFile(IContentType contentType, string sourcePath, string minPath, IMinifierSettings settings, bool compilerNeedsSourceMap = true)
{
IFileMinifier minifier = Mef.GetImport <IFileMinifier>(contentType);
bool changed = await minifier.MinifyFile(sourcePath, minPath, compilerNeedsSourceMap);
if (settings.GzipMinifiedFiles && (changed || !File.Exists(minPath + ".gzip")))
{
FileHelpers.GzipFile(minPath);
}
}
private static void MinifyFile(IContentType contentType, string sourcePath, string minPath, IMinifierSettings settings)
{
IFileMinifier minifier = Mef.GetImport <IFileMinifier>(contentType);
bool changed = minifier.MinifyFile(sourcePath, minPath);
if (settings.GzipMinifiedFiles && (changed || !File.Exists(minPath + ".gzip")))
{
FileHelpers.GzipFile(minPath);
}
}
public void SubjectBuffersConnected(IWpfTextView textView, ConnectionReason reason, Collection <ITextBuffer> subjectBuffers)
{
ITextDocument document;
if (TextDocumentFactoryService.TryGetTextDocument(textView.TextDataModel.DocumentBuffer, out document))
{
textView.Properties.GetOrCreateSingletonProperty("HandlebarsCompilationNotifier", () =>
Mef.GetImport <ICompilationNotifierProvider>(ContentTypeManager.GetContentType("Handlebars"))
.GetCompilationNotifier(document));
}
}
private DependencyGraph GetGraph(IContentType contentType)
{
var graph = (VsDependencyGraph)Mef.GetImport <DependencyGraph>(contentType);
if (!registeredContentTypes.Add(contentType))
{
return(graph);
}
// Add this event handler only once per ContentType
var settings = WESettings.Instance.ForContentType <IChainableCompilerSettings>(contentType);
graph.IsEnabled = settings.EnableChainCompilation;
settings.EnableChainCompilationChanged += delegate { graph.IsEnabled = settings.EnableChainCompilation; };
return(graph);
}
public Task CompileFilesAsync(IContentType contentType, IEnumerable <string> paths)
{
var exts = FileExtensionRegistry.GetFileExtensionSet(contentType);
var runner = Mef.GetImport <ICompilerRunnerProvider>(contentType).GetCompiler(contentType);
return(Task.WhenAll(
paths.Where(f => exts.Contains(Path.GetExtension(f)))
.AsParallel()
.Select(fileName =>
{
string targetPath = runner.GetTargetPath(fileName);
if (File.Exists(targetPath) || ProjectHelpers.GetProjectItem(targetPath) != null)
{
return runner.CompileAsync(fileName, targetPath).HandleErrors("compiling" + fileName);
}
else
{
return Task.FromResult <CompilerResult>(null);
}
})
));
}
public NodeCompilerRunner(IContentType contentType)
: base(contentType)
{
Compiler = Mef.GetImport <NodeExecutorBase>(contentType);
}
