private async static Task AddScript(string filePath, string extension, IEnumerable <IntellisenseObject> list)
{
string resultPath = filePath + extension;
if (!File.Exists(resultPath))
{
return;
}
await IntellisenseWriter.Write(list, resultPath);
var item = ProjectHelpers.AddFileToProject(filePath, resultPath);
if (item == null)
{
return;
}
if (extension.Equals(IntellisenseParser.Ext.TypeScript, StringComparison.OrdinalIgnoreCase))
{
item.Properties.Item("ItemType").Value = "TypeScriptCompile";
}
else
{
item.Properties.Item("ItemType").Value = "None";
}
}
public async static Task <bool> MakeBundle(BundleDocument document, string bundleFile, Func <string, bool, Task> updateBundle)
{
// filePath must end in ".targetExtension.bundle"
string extension = Path.GetExtension(Path.GetFileNameWithoutExtension(document.FileName));
if (string.IsNullOrEmpty(extension))
{
Logger.Log("Skipping bundle file " + document.FileName + " without extension. Bundle files must end with the output extension, followed by '.bundle'.");
return(false);
}
Dictionary <string, string> files = await WatchFiles(document, updateBundle, bundleFile);
string combinedContent = await CombineFiles(files, extension, document, bundleFile);
bool bundleChanged = !File.Exists(bundleFile) || await FileHelpers.ReadAllTextRetry(bundleFile) != combinedContent;
if (bundleChanged)
{
if (!ProjectHelpers.CheckOutFileFromSourceControl(bundleFile))
{
throw new Exception("There was a problem checking out the file: " + bundleFile);
}
await FileHelpers.WriteAllTextRetry(bundleFile, combinedContent);
Logger.Log("Web Essentials: Updated bundle: " + Path.GetFileName(bundleFile));
}
ProjectHelpers.AddFileToProject(document.FileName, bundleFile);
return(bundleChanged);
}
protected async override Task RtlVariantHandler(CompilerResult result)
{
if (!WESettings.Instance.Css.RtlCss || result.RtlTargetFileName == null)
{
return;
}
string value = PostProcessResult(result.RtlResult, result.RtlTargetFileName, result.RtlSourceFileName);
// Write output file
if (result.RtlTargetFileName != null && (MinifyInPlace || !File.Exists(result.RtlTargetFileName) ||
value != await FileHelpers.ReadAllTextRetry(result.RtlTargetFileName)))
{
ProjectHelpers.CheckOutFileFromSourceControl(result.RtlTargetFileName);
await FileHelpers.WriteAllTextRetry(result.RtlTargetFileName, value);
ProjectHelpers.AddFileToProject(result.RtlSourceFileName, result.RtlTargetFileName);
}
// Write map file
if (GenerateSourceMap && (!File.Exists(result.RtlMapFileName) ||
result.RtlResultMap != await FileHelpers.ReadAllTextRetry(result.RtlMapFileName)))
{
ProjectHelpers.CheckOutFileFromSourceControl(result.RtlMapFileName);
await FileHelpers.WriteAllTextRetry(result.RtlMapFileName, result.RtlResultMap);
ProjectHelpers.AddFileToProject(result.RtlTargetFileName, result.RtlMapFileName);
}
}
private async Task GenerateAsync(BundleDocument bundle, string extension, bool hasUpdated = false)
{
_dte.StatusBar.Text = "Generating bundle...";
if (ProjectHelpers.GetProjectItem(bundle.FileName) == null)
{
ProjectHelpers.AddFileToActiveProject(bundle.FileName);
}
string bundleFile = Path.Combine(Path.GetDirectoryName(bundle.FileName), Path.GetFileNameWithoutExtension(bundle.FileName));
if (!string.IsNullOrEmpty(bundle.OutputDirectory))
{
bundleFile = ProjectHelpers.GetAbsolutePathFromSettings(bundle.OutputDirectory, Path.Combine(Path.GetDirectoryName(bundle.FileName), Path.GetFileNameWithoutExtension(bundle.FileName)));
}
ProjectHelpers.CreateDirectoryInProject(bundleFile);
bool hasChanged = await BundleGenerator.MakeBundle(bundle, bundleFile, UpdateBundleAsync);
ProjectHelpers.AddFileToProject(bundle.FileName, bundleFile);
if (!hasUpdated)
{
WebEssentialsPackage.DTE.ItemOperations.OpenFile(bundle.FileName);
}
if (bundle.Minified)
{
await BundleGenerator.MakeMinFile(bundleFile, extension, hasChanged);
}
_dte.StatusBar.Text = "Bundle generated";
}
private async Task GenerateAsync(BundleDocument bundle, string extension, bool hasUpdated = false)
{
_dte.StatusBar.Text = "Generating bundle...";
if (!hasUpdated)
{
ProjectHelpers.AddFileToActiveProject(bundle.FileName);
}
string bundleFile = Path.Combine(Path.GetDirectoryName(bundle.FileName), Path.GetFileNameWithoutExtension(bundle.FileName));
bool hasChanged = await BundleGenerator.MakeBundle(bundle, bundleFile, UpdateBundleAsync);
if (!hasUpdated)
{
ProjectHelpers.AddFileToProject(bundle.FileName, bundleFile);
EditorExtensionsPackage.DTE.ItemOperations.OpenFile(bundle.FileName);
}
if (bundle.Minified)
{
await BundleGenerator.MakeMinFile(bundleFile, extension, hasChanged);
}
_dte.StatusBar.Text = "Bundle generated";
}
private static void Export(IEnumerable <SpriteFragment> fragments, string imageFile)
{
foreach (ExportFormat format in (ExportFormat[])Enum.GetValues(typeof(ExportFormat)))
{
string exportFile = SpriteExporter.Export(fragments, imageFile, format);
ProjectHelpers.AddFileToProject(imageFile, exportFile);
}
}
// Don't try-catch this method: We need to "address" all the bugs,
// which may occur as the (node.js-based) service implement changes.
private async Task <CompilerResult> ProcessResult(CompilerResult result, bool onlyPreview, string sourceFileName, string targetFileName)
{
if (result == null)
{
Logger.Log(ServiceName + ": " + Path.GetFileName(sourceFileName) + " compilation failed: The service failed to respond to this request\n\t\t\tPossible cause: Syntax Error!");
return(await CompilerResultFactory.GenerateResult(sourceFileName, targetFileName));
}
if (!result.IsSuccess)
{
var firstError = result.Errors.Where(e => e != null).Select(e => e.Message).FirstOrDefault();
if (firstError != null)
{
Logger.Log(firstError);
}
return(result);
}
string resultString = PostProcessResult(result.Result, result.TargetFileName, result.SourceFileName);
if (!onlyPreview)
{
// Write output file
if (result.TargetFileName != null && (MinifyInPlace || !File.Exists(result.TargetFileName) ||
resultString != await FileHelpers.ReadAllTextRetry(result.TargetFileName)))
{
ProjectHelpers.CheckOutFileFromSourceControl(result.TargetFileName);
await FileHelpers.WriteAllTextRetry(result.TargetFileName, resultString);
if (!(this is ILintCompiler))
{
ProjectHelpers.AddFileToProject(result.SourceFileName, result.TargetFileName);
}
}
// Write map file
if (GenerateSourceMap && (!File.Exists(result.MapFileName) ||
result.ResultMap != await FileHelpers.ReadAllTextRetry(result.MapFileName)))
{
ProjectHelpers.CheckOutFileFromSourceControl(result.MapFileName);
await FileHelpers.WriteAllTextRetry(result.MapFileName, result.ResultMap);
if (!(this is ILintCompiler))
{
ProjectHelpers.AddFileToProject(result.TargetFileName, result.MapFileName);
}
}
await RtlVariantHandler(result);
}
return(CompilerResult.UpdateResult(result, resultString));
}
public static void GzipFile(string sourcePath)
{
var gzipPath = sourcePath + ".gzip";
ProjectHelpers.CheckOutFileFromSourceControl(gzipPath);
using (var sourceStream = File.OpenRead(sourcePath))
using (var targetStream = File.OpenWrite(gzipPath))
using (var gzipStream = new GZipStream(targetStream, CompressionMode.Compress))
sourceStream.CopyTo(gzipStream);
ProjectHelpers.AddFileToProject(sourcePath, gzipPath);
}
private async Task GenerateAsync(SpriteDocument sprite)
{
_dte.StatusBar.Text = "Generating sprite...";
string imageFile;
var fragments = SpriteGenerator.CreateImage(sprite, out imageFile);
ProjectHelpers.AddFileToActiveProject(sprite.FileName);
ProjectHelpers.AddFileToProject(sprite.FileName, imageFile);
Export(fragments, imageFile);
if (sprite.Optimize)
{
await new ImageCompressor().CompressFilesAsync(imageFile);
}
_dte.StatusBar.Text = "Sprite generated";
}
private async Task HandleRtlCss(CompilerResult result)
{
string value = result.RtlResult;
// Write output file
if (result.RtlTargetFileName != null && (MinifyInPlace || !File.Exists(result.RtlTargetFileName) ||
value != await FileHelpers.ReadAllTextRetry(result.RtlTargetFileName)))
{
ProjectHelpers.CheckOutFileFromSourceControl(result.RtlTargetFileName);
await FileHelpers.WriteAllTextRetry(result.RtlTargetFileName, value);
ProjectHelpers.AddFileToProject(result.RtlSourceFileName, result.RtlTargetFileName);
}
// Write map file
if (GenerateSourceMap && (!File.Exists(result.RtlMapFileName) ||
result.RtlResultMap != await FileHelpers.ReadAllTextRetry(result.RtlMapFileName)))
{
ProjectHelpers.CheckOutFileFromSourceControl(result.RtlMapFileName);
await FileHelpers.WriteAllTextRetry(result.RtlMapFileName, result.RtlResultMap);
ProjectHelpers.AddFileToProject(result.RtlTargetFileName, result.RtlMapFileName);
}
}
private async static Threading.Task WriteBundleFile(string bundleFilePath, XmlDocument doc)
{
XmlNode bundleNode = doc.SelectSingleNode("//bundle");
if (bundleNode == null)
{
return;
}
XmlNode outputAttr = bundleNode.Attributes["output"];
if (outputAttr != null && (outputAttr.InnerText.Contains("/") || outputAttr.InnerText.Contains("\\")))
{
Logger.ShowMessage(String.Format(CultureInfo.CurrentCulture, "The 'output' attribute should contain a file name without a path; '{0}' is not valid", outputAttr.InnerText));
return;
}
Dictionary <string, string> files = new Dictionary <string, string>();
// filePath must end in ".targetExtension.bundle"
string extension = Path.GetExtension(Path.GetFileNameWithoutExtension(bundleFilePath));
if (string.IsNullOrEmpty(extension))
{
Logger.Log("Skipping bundle file " + bundleFilePath + " without extension. Bundle files must end with the output extension, followed by '.bundle'.");
return;
}
XmlNodeList nodes = doc.SelectNodes("//file");
foreach (XmlNode node in nodes)
{
string absolute;
if (node.InnerText.Contains(":\\"))
{
absolute = node.InnerText;
}
else
{
absolute = ProjectHelpers.ToAbsoluteFilePath(node.InnerText, bundleFilePath);
}
if (File.Exists(absolute))
{
if (!files.ContainsKey(absolute))
{
files.Add(absolute, node.InnerText);
}
}
else
{
_dte.ItemOperations.OpenFile(bundleFilePath);
Logger.ShowMessage(String.Format(CultureInfo.CurrentCulture, "Bundle error: The file '{0}' doesn't exist", node.InnerText));
return;
}
}
string bundleSourcePath = outputAttr != null?Path.Combine(Path.GetDirectoryName(bundleFilePath), outputAttr.InnerText) : bundleFilePath.Replace(_ext, string.Empty);
StringBuilder sb = new StringBuilder();
foreach (string file in files.Keys)
{
//if (extension.Equals(".css", StringComparison.OrdinalIgnoreCase))
//{
// sb.AppendLine("/*#source " + files[file] + " */");
//}
if (extension.Equals(".js", StringComparison.OrdinalIgnoreCase) && WESettings.Instance.JavaScript.GenerateSourceMaps)
{
sb.AppendLine("///#source 1 1 " + files[file]);
}
if (!File.Exists(file))
{
continue;
}
await new BundleFileWatcher().AttachFileObserverEvent(file);
var source = await FileHelpers.ReadAllTextRetry(file);
if (extension.Equals(".css", StringComparison.OrdinalIgnoreCase))
{
// If the bundle is in the same folder as the CSS,
// or if does not have URLs, no need to normalize.
if (Path.GetDirectoryName(file) != Path.GetDirectoryName(bundleSourcePath) &&
source.IndexOf("url(", StringComparison.OrdinalIgnoreCase) > 0 &&
WESettings.Instance.Css.AdjustRelativePaths)
{
source = CssUrlNormalizer.NormalizeUrls(
tree: new CssParser().Parse(source, true),
targetFile: bundleSourcePath,
oldBasePath: file
);
}
}
sb.AppendLine(source);
}
bool bundleChanged = !File.Exists(bundleSourcePath) || await FileHelpers.ReadAllTextRetry(bundleSourcePath) != sb.ToString();
if (bundleChanged)
{
ProjectHelpers.CheckOutFileFromSourceControl(bundleSourcePath);
await FileHelpers.WriteAllTextRetry(bundleSourcePath, sb.ToString());
Logger.Log("Web Essentials: Updated bundle: " + Path.GetFileName(bundleSourcePath));
}
ProjectHelpers.AddFileToProject(bundleFilePath, bundleSourcePath);
if (bundleNode.Attributes["minify"] != null && bundleNode.Attributes["minify"].InnerText == "true")
{
await WriteMinFile(bundleSourcePath, extension, bundleChanged);
}
}
