private void ApplyOverrides(string configFileName, ITaskRunnerNode parent)
{
var currentExtensionMatch = Regex.Match(configFileName, "webpack\\.config\\.(?<ext>.+)$");
var currentExtension = currentExtensionMatch.Groups["ext"];
var files = Directory
.EnumerateFiles(parent.Command.WorkingDirectory)
.Where(f => f.Contains("webpack.") && f.EndsWith($".config.{currentExtension}", StringComparison.OrdinalIgnoreCase));
foreach (string file in files)
{
string fileName = Path.GetFileName(file);
Match match = Regex.Match(fileName, $"webpack\\.(?<env>[^\\.]+)\\.config\\.{currentExtension}");
if (!match.Success)
{
continue;
}
var task = new TaskRunnerNode($"config: {match.Groups["env"].Value}", true)
{
Description = $"Runs '{parent.Name} --config {fileName}'",
Command = GetCommand(parent.Command.WorkingDirectory, $"{parent.Command.Args.Replace("webpack ", $"webpack --config {fileName} ")}")
};
parent.Children.Add(task);
}
}
public async Task <ITaskRunnerConfig> ParseConfig(ITaskRunnerCommandContext context, string configPath)
{
return(await Task.Run(async() => {
ITaskRunnerNode hierarchy = await TryLoadHierarchy(configPath);
return new GulpTaskRunnerConfig(hierarchy);
}));
}
public void ToggleBinding(TaskRunnerBindEvent bindEvent, ITaskRunnerNode task)
{
if (config == null)
{
return;
}
TaskRunnerBindingInformation binding = FindBinding(bindEvent);
if (binding != null)
{
binding.ToggleTask(task);
if (!binding.AnyTasks())
{
bindings.Remove(binding);
}
}
else
{
binding = new TaskRunnerBindingInformation(bindEvent, task);
bindings.Add(binding);
}
config.SaveBindings(configFile, ToXml());
}
IEnumerable <TaskRunnerTreeNode> GetChildNodes(ITaskRunnerNode task, bool bold = false)
{
foreach (ITaskRunnerNode childTask in task.Children)
{
yield return(new TaskRunnerTreeNode(taskRunnerInfo, childTask, bold));
}
}
private void AppendCommands(ref ITaskRunnerNode root, string configPath, string name, string description)
{
string rootDir = Path.GetDirectoryName(configPath);
IEnumerable <CommandTask> commands = TaskParser.LoadTasks(configPath);
if (commands == null)
{
return;
}
var tasks = new TaskRunnerNode(name);
tasks.Description = description;
root.Children.Add(tasks);
foreach (CommandTask command in commands.OrderBy(k => k.Name))
{
command.Name = SetVariables(command.Name, rootDir);
command.WorkingDirectory = SetVariables(command.WorkingDirectory, rootDir);
string cwd = command.WorkingDirectory ?? rootDir;
// Add zero width space
string commandName = command.Name;
var task = new TaskRunnerNode(commandName, true)
{
Command = new DynamicTaskRunnerCommand(this, rootDir, cwd, command.FileName, command.Arguments),
Description = $"Filename:\t {command.FileName}\r\nArguments:\t {command.Arguments}"
};
tasks.Children.Add(task);
}
}
static string GetBuildWarning(ITaskRunnerNode task, ITaskRunnerCommandResult result)
{
return(GettextCatalog.GetString(
"Task {0} failed with exit code {1}. Command: {2}",
task.Name,
result.ExitCode,
task.Command.ToCommandLine()));
}
void ToggleBinding(TaskRunnerInformation taskRunnerInfo, ITaskRunnerNode node, TaskRunnerBindEvent bindEvent)
{
try {
taskRunnerInfo.ToggleBinding(bindEvent, node);
} catch (Exception ex) {
LoggingService.LogError("Toggle binding failed.", ex);
MessageService.ShowError(GettextCatalog.GetString("Unable to change binding."), ex);
}
}
void RunTask(ITaskRunnerNode taskRunnerNode, IEnumerable <ITaskRunnerOption> options)
{
try {
var task = new TaskRunnerWithOptions(taskRunnerNode, options);
RunTaskAsync(task).Ignore();
} catch (Exception ex) {
LoggingService.LogError("TaskRunnerExplorerPad.RunTask error", ex);
}
}
public async Task <ITaskRunnerConfig> ParseConfig(ITaskRunnerCommandContext context, string configPath)
{
return(await Task.Run(() =>
{
ITaskRunnerNode hierarchy = LoadHierarchy(configPath);
return new TaskRunnerConfig(context, hierarchy, _icon);
}));
}
/// <summary>
/// Removes all errors for a given task and updates the CurrentSnapshot
/// </summary>
internal void ClearErrors(ITaskRunnerNode task)
{
List <IErrorListItem> taskErrors = _currentErrors.Where(e => IsSameCommand(e.Command, task.Command)).ToList();
if (taskErrors.Any())
{
_currentErrors = _currentErrors.Except(taskErrors).ToList();
UpdateErrors(new OutputErrorSnapshot(CurrentSnapshot.VersionNumber + 1, _currentErrors));
}
}
/// <summary>
/// Parses a configuration file into ITaskRunnerConfig
/// </summary>
/// <param name="configPath"></param>
/// <param name="taskRunnerOptions"></param>
/// <param name="environmentPath"></param>
/// <param name="projectItem"></param>
/// <returns></returns>
public async Task <ITaskRunnerConfig> ParseConfig(ITaskRunnerCommandContext context, string configPath)
{
//Custom
await Geoffrey.EnsureInitialized(context);
ITaskRunnerNode hierarchy = LoadHierarchy(configPath);
//Common
return(new TaskRunnerConfig <PowershellBindingsPersister>(context, hierarchy, _icon));
}
public void ToggleTask(ITaskRunnerNode task)
{
int count = taskNames.Count;
taskNames.RemoveAll(name => IsMatch(task, name));
if (count == taskNames.Count)
{
taskNames.Add(task.Name);
}
}
public bool IsBindingEnabled(TaskRunnerBindEvent bindEvent, ITaskRunnerNode taskRunnerNode)
{
TaskRunnerBindingInformation binding = FindBinding(bindEvent);
if (binding != null)
{
return(binding.HasTask(taskRunnerNode));
}
return(false);
}
public TaskRunnerTreeNode(TaskRunnerInformation task, ITaskRunnerNode node, bool bold)
{
taskRunnerInfo = task;
taskRunnerNode = node;
Name = taskRunnerNode.Name ?? string.Empty;
Icon = task.Icon;
if (bold)
{
Name = Name.ToBoldMarkup();
}
}
public async Task <ITaskRunnerConfig> ParseConfig(ITaskRunnerCommandContext context, string configPath)
{
try {
return(await Task.Run(() => {
TaskRunnerLogger.WriteLine("TestTaskRunnerProvider.ParseConfig configPath={0}", configPath);
ITaskRunnerNode hierarchy = LoadHierarchy(configPath);
return new TaskRunnerConfig(hierarchy);
}));
} catch (Exception ex) {
TaskRunnerLogger.WriteLine("Load failed. {0}", ex.Message);
return(CreateErrorTaskRunnerConfig(ex));
}
}
public async Task <ITaskRunnerConfig> ParseConfig(ITaskRunnerCommandContext context, string configPath)
{
return(await Task.Run(() =>
{
ITaskRunnerNode hierarchy = LoadHierarchy(configPath);
if (!hierarchy.Children.Any() && !hierarchy.Children.First().Children.Any())
{
return null;
}
return new TaskRunnerConfig(this, context, hierarchy, _icon);
}));
}
public async Task <ITaskRunnerConfig> ParseConfig(ITaskRunnerCommandContext context, string configPath)
{
return(await Task.Run(() =>
{
if (!BundlerMinifierPackage.Options.EnableTaskRunnerExplorer)
{
return null;
}
ITaskRunnerNode hierarchy = LoadHierarchy(configPath);
return new TaskRunnerConfig(context, hierarchy, _icon);
}));
}
public async Task <ITaskRunnerConfig> ParseConfig(ITaskRunnerCommandContext context, string configPath)
{
return(await Task.Run(() =>
{
var userPathConfig = configPath.Replace(Constants.FILENAME, Constants.USERFILENAME);
ITaskRunnerNode hierarchy = LoadHierarchy(configPath, userPathConfig);
if (!hierarchy.Children.Any() && !hierarchy.Children.First().Children.Any())
{
return null;
}
return new TaskRunnerConfig(hierarchy, _icon);
}));
}
static ITaskRunnerNode GetInvokableTask(string name, IEnumerable <ITaskRunnerNode> tasks)
{
foreach (ITaskRunnerNode task in tasks)
{
if (task.Invokable && task.Name == name)
{
return(task);
}
ITaskRunnerNode foundTask = GetInvokableTask(name, task.Children);
if (foundTask != null)
{
return(foundTask);
}
}
return(null);
}
private void ApplyOverrides(ITaskRunnerNode parent)
{
var files = Directory.EnumerateFiles(parent.Command.WorkingDirectory).Where(f => f.Contains(".overrides."));
foreach (string file in files)
{
int dot = file.LastIndexOf('.');
string name = file.Substring(dot + 1);
var task = new TaskRunnerNode($"env: {name}", true)
{
Description = $"Runs '{parent.Name} --env {name}'",
Command = GetCommand(parent.Command.WorkingDirectory, $"{parent.Command.Args} --env {name}")
};
parent.Children.Add(task);
}
}
public IEnumerable <TaskRunnerWithOptions> GetTasks(TaskRunnerBindEvent bindEvent)
{
foreach (TaskRunnerInformation task in Tasks)
{
foreach (TaskRunnerBindingInformation binding in task.Bindings)
{
if (binding.BindEvent == bindEvent)
{
foreach (string taskName in binding.GetTasks())
{
ITaskRunnerNode node = task.GetInvokableTask(taskName);
if (node != null)
{
yield return(new TaskRunnerWithOptions(node, task.Options));
}
}
}
}
}
}
private static List <IErrorListItem> RemoveErrorDuplicates(ITaskRunnerNode task,
string projectName,
OutputParserResult parserOutput,
OutputErrorSnapshot currentSnapshot)
{
List <IErrorListItem> newErrors = new List <IErrorListItem>();
foreach (IErrorListItem error in parserOutput.ErrorList)
{
error.ProjectName = projectName;
error.ErrorSource = task.Name;
error.Filename = Path.Combine(task.Command.WorkingDirectory, error.Filename);
error.Command = task.Command;
if (!currentSnapshot.Errors.Contains(error))
{
newErrors.Add(error);
}
}
return(newErrors);
}
/// <summary>
/// Handles the command output (inputLines) and generates errors as appropriate.
/// </summary>
/// <param name="task">Task being executed</param>
/// <param name="projectName">Project name of the task</param>
/// <param name="inputLines">Set of command output messages to be parsed</param>
/// <returns></returns>
public IEnumerable <string> HandleLines(ITaskRunnerNode task, string projectName, IEnumerable <string> lines)
{
bool errorListNeedsUpdate = false;
// Remove existing Factory errors associated with the running task after idle time
if (_timer.ElapsedMilliseconds > 1000)
{
_factory.ClearErrors(task);
errorListNeedsUpdate = true;
}
OutputParserResult parserOutput = _outputParser.ParseOutput(lines);
if (parserOutput != null && parserOutput.ErrorList.Count() > 0)
{
OutputErrorSnapshot currentSnapshot = _factory.CurrentSnapshot as OutputErrorSnapshot;
List <IErrorListItem> newErrors = RemoveErrorDuplicates(task, projectName, parserOutput, currentSnapshot);
if (newErrors.Count > 0)
{
_factory.AddErrorItems(newErrors);
errorListNeedsUpdate = true;
}
}
// Only update the errors list if Factory errors has changed.
if (errorListNeedsUpdate)
{
UpdateErrorsList();
}
// Reset and start the timer to measure new elapsed time between new line(s) inputs
_timer.Reset();
_timer.Start();
return(parserOutput.OutputLines);
}
protected TaskRunnerConfigBase(ITaskRunnerCommandContext context, ITaskRunnerNode hierarchy)
{
TaskHierarchy = hierarchy;
_context = context;
}
private void ApplyOverrides(ITaskRunnerNode parent)
{
var files = Directory.EnumerateFiles(parent.Command.WorkingDirectory).Where(f => f.Contains("webpack.") && f.EndsWith(".config.js"));
foreach (string file in files)
{
string fileName = Path.GetFileName(file);
Match match = Regex.Match(fileName, "webpack\\.(?<env>[^\\.]+)\\.config(\\.babel)?\\.js");
if (!match.Success)
continue;
var task = new TaskRunnerNode($"config: {match.Groups["env"].Value}", true)
{
Description = $"Runs '{parent.Name} --config {fileName}'",
Command = GetCommand(parent.Command.WorkingDirectory, $"{parent.Command.Args.Replace("webpack ", $"webpack --config {fileName} ")}")
};
parent.Children.Add(task);
}
}
public TaskRunnerConfig(ITaskRunnerNode hierarchy, ImageSource icon)
{
_hierarchy = hierarchy;
_icon = icon;
}
protected TaskRunnerConfigBase(TaskRunnerProvider provider, ITaskRunnerCommandContext context, ITaskRunnerNode hierarchy)
{
_bindingsPersister = new BindingsPersister(provider);
TaskHierarchy = hierarchy;
_context = context;
}
public TaskRunnerConfig(ITaskRunnerCommandContext context, ITaskRunnerNode hierarchy)
: base(context, hierarchy)
{
}
public TaskRunnerConfig(ITaskRunnerCommandContext context, ITaskRunnerNode hierarchy, ImageSource rootNodeIcon)
: this(context, hierarchy)
{
_rootNodeIcon = rootNodeIcon;
}
protected TaskRunnerConfigBase(ITaskRunnerCommandContext context, ITaskRunnerNode hierarchy)
{
TaskHierarchy = hierarchy;
_context = context;
}
protected TaskRunnerConfigBase(TaskRunnerProvider provider, ITaskRunnerCommandContext context, ITaskRunnerNode hierarchy)
{
_bindingsPersister = new BindingsPersister(provider);
TaskHierarchy = hierarchy;
_context = context;
}
private void ApplyOverrides(ITaskRunnerNode parent)
{
var files = Directory.EnumerateFiles(parent.Command.WorkingDirectory).Where(f => f.Contains(".overrides."));
foreach (string file in files)
{
int dot = file.LastIndexOf('.');
string name = file.Substring(dot + 1);
var task = new TaskRunnerNode($"env: {name}", true)
{
Description = $"Runs '{parent.Name} --env {name}'",
Command = GetCommand(parent.Command.WorkingDirectory, $"{parent.Command.Args} --env {name}")
};
parent.Children.Add(task);
}
}
public TaskRunnerConfig(ITaskRunnerCommandContext context, ITaskRunnerNode hierarchy, ImageSource icon)
{
_context = context;
TaskHierarchy = hierarchy;
Icon = icon;
}
public TaskRunnerConfig(ITaskRunnerNode hierarchy)
{
TaskHierarchy = hierarchy;
}
public void Dispose()
{
_icon = null;
_hierarchy = null;
}
public TaskRunnerConfig(ITaskRunnerCommandContext context, ITaskRunnerNode hierarchy, ImageSource icon)
{
_context = context;
_hierarchy = hierarchy;
_icon = icon;
}
public ManifestTaskRunnerConfig(ITaskRunnerNode rootNode)
{
TaskHierarchy = rootNode;
}
public TaskRunnerConfig(TaskRunnerProvider provider, ITaskRunnerCommandContext context, ITaskRunnerNode hierarchy)
: base(provider, context, hierarchy)
{
}
