protected override PropertyItem CalculateAggregation(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
double minimum = double.MaxValue;
Enum unit = null;
foreach (ProcessorItem item in items)
{
PropertyItem property = GetProperty(pipeline, item);
if (property == null)
{
continue;
}
if (!property.IsNumeric)
{
pipeline.Output.WriteLine(Level.Warn, "The avg processor can only average numeric properties!");
return(null);
}
minimum = Math.Min(minimum, property.ValueNumber);
unit = property.Unit;
}
return(new PropertyItem(minimum, unit));
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
foreach (ProcessorItem item in items)
{
string propertyValue = item.GetProperty(pipeline.PropertyProvider, property).ValueText;
Match match = regex.Match(propertyValue);
if (match.Success)
{
item.TryCachePropertyValue(key, CreatePropertyItem(match.Value));
if (match.Groups.Count > 1)
{
for (int i = 1; i < match.Groups.Count; i++)
{
Group group = match.Groups[i];
if (!group.Success)
{
continue;
}
item.TryCachePropertyValue($"{key}{i - 1}", CreatePropertyItem(group.Value));
}
}
}
yield return(item);
}
}
protected override PropertyItem CalculateAggregation(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
double total = 0;
Enum unit = null;
foreach (ProcessorItem item in items)
{
PropertyItem property = GetProperty(pipeline, item);
if (property == null)
{
continue;
}
if (!property.IsNumeric)
{
pipeline.Output.WriteLine(Level.Warn, "The sum processor can only sum numeric properties!");
return(null);
}
total += property.ValueNumber;
unit = property.Unit;
}
return(new PropertyItem(total, unit));
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
if (!pipeline.Simulate)
{
File.WriteAllLines(path, items.Select(x => x.Value), Encoding.UTF8);
}
return(items);
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
foreach (ProcessorItem item in items)
{
item.Value = template.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item);
yield return(item);
}
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
int i = 1;
foreach (ProcessorItem item in items)
{
item.TryCachePropertyValue("index", new PropertyItem(i++, null), true);
yield return(item);
}
}
private IEnumerable <ProcessorItem> Eval(IProcessorPipeline pipeline, string value)
{
List <IProcessor> processors = pipeline.Interpreter.Eval(value);
if (processors.Count > 0)
{
return(pipeline.Process(processors));
}
return(Enumerable.Empty <ProcessorItem>());
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
object selector(ProcessorItem item)
{
PropertyItem property = item.GetProperty(pipeline.PropertyProvider, itemPropertyName);
return(property.IsNumeric ? property.ValueNumber : 0);
}
return(isDescending ? items.OrderByDescending(selector) : items.OrderBy(selector));
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
if (!File.Exists(path))
{
return(items);
}
IEnumerable <ProcessorItem> fileItems = File.ReadLines(path, Encoding.UTF8).Select(x => new ProcessorItem(x));
return(items.Concat(fileItems));
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
int i = 0;
foreach (ProcessorItem item in items)
{
pipeline.Output.WriteLine(Level.None, $"&-8;{i++,3}:&-^; {item.Value}");
}
return(items);
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
PropertyItem result = CalculateAggregation(pipeline, items);
if (result != null)
{
string gPropertyName = outputPropertyName ?? $"{Key}_{itemPropertyName}";
pipeline.PropertyStore.SetProperty(gPropertyName, result);
}
return(items);
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
if (pipeline.Simulate)
{
pipeline.Output.WriteLine(Utility.Level.Info, $"\n&-c;-------- Simulation Mode Active! --------&-^;\n");
}
foreach (ProcessorItem item in items)
{
string srcFilepath = item.Value;
string dstFilepath = dstTemplate.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item);
pipeline.Output.WriteLine(Utility.Level.Info, $"Copying: &-6;{srcFilepath}&-^; -> &-6;{dstFilepath}&-^;");
if (!pipeline.Simulate)
{
if (File.Exists(srcFilepath))
{
string dir = Path.GetDirectoryName(dstFilepath);
if (!string.IsNullOrEmpty(dir))
{
Directory.CreateDirectory(dir);
}
if (!File.Exists(dstFilepath))
{
File.Copy(srcFilepath, dstFilepath);
}
else
{
pipeline.Output.WriteLine(Utility.Level.Info, $" - &-c;Destination filepath already exists! Ignoring...&-^;");
}
}
else
{
pipeline.Output.WriteLine(Utility.Level.Info, $" - &-c;Source filepath doesn't exist! Ignoring...&-^;");
}
}
}
return(items);
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
IEnumerable <ProcessorItem> result = appendOutput ? items : Enumerable.Empty <ProcessorItem>();
if (joinInput)
{
string value = string.Join(" ", items.Select(x => x.Value));
result = result.Concat(Eval(pipeline, value));
}
else
{
foreach (ProcessorItem item in items)
{
result = result.Concat(Eval(pipeline, item.Value));
}
}
return(result);
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
if (pipeline.Simulate)
{
pipeline.Output.WriteLine(Level.Info, $"\n&-c;-------- Simulation Mode Active! --------&-^;\n");
}
foreach (ProcessorItem item in items)
{
string path = template.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item);
pipeline.Output.WriteLine(Level.Info, $"MkDir: &-6;{path}&-^;");
if (!pipeline.Simulate)
{
Directory.CreateDirectory(path);
}
}
return(items);
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
foreach (ProcessorItem inputItem in items)
{
if (!Directory.Exists(inputItem.Value))
{
continue;
}
IEnumerable <string> enumerable = isFiles ?
Directory.EnumerateFiles(inputItem.Value, "*", searchOption)
:
Directory.EnumerateDirectories(inputItem.Value, "*", searchOption);
foreach (string filepath in enumerable)
{
yield return(new ProcessorItem(filepath, inputItem.Value));
}
}
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
return(items.Where(x => glob.IsMatch(x.Value)));
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
return(items.Concat(newItems.Select(x => new ProcessorItem(x))));
}
// scan files top >> extract "S(\d\d)E(\d\d)" from @{name} as @{ep} >> set @{ep1} + 51 >> rename "Black Clover - Season @{ep0} - Episode @{ep1}.@{ext}"
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
return(items);
}
protected abstract PropertyItem CalculateAggregation(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items);
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
System.Diagnostics.ProcessStartInfo info = new System.Diagnostics.ProcessStartInfo()
{
CreateNoWindow = noWindow,
ErrorDialog = false,
UseShellExecute = !noWindow,
RedirectStandardOutput = noWindow,
RedirectStandardError = noWindow
};
if (pipeline.Simulate)
{
pipeline.Output.WriteLine(Utility.Level.Info, $"\n&-c;-------- Simulation Mode Active! --------&-^;\n");
}
foreach (ProcessorItem item in items)
{
string exeFilepath = exeTemplate.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item);
string exeArguments = argsTemplate.Make(pipeline.PropertyProvider, pipeline.PropertyStore, item);
info.FileName = exeFilepath;
info.Arguments = exeArguments;
System.Diagnostics.Process process = !pipeline.Simulate ? new System.Diagnostics.Process {
StartInfo = info
} : null;
if (noWindow && !pipeline.Simulate)
{
process.OutputDataReceived += (p, data) => pipeline.Output.WriteLine(Level.None, data.Data, true);
process.ErrorDataReceived += (p, data) => pipeline.Output.WriteLine(Level.None, data.Data, true);
}
try {
process?.Start();
pipeline.Output.WriteLine(Level.None, $"Executing: {exeFilepath} {exeArguments}");
if (noWindow)
{
process?.BeginErrorReadLine();
process?.BeginOutputReadLine();
}
if (wait)
{
process?.WaitForExit();
}
} catch (Win32Exception) {
pipeline.Output.WriteLine(Level.Error, $"&-c;Failed to execute: {exeFilepath} {exeArguments}&-^;");
}
}
return(items);
}
protected PropertyItem GetProperty(IProcessorPipeline pipeline, ProcessorItem item)
{
return(item.GetProperty(pipeline.PropertyProvider, itemPropertyName));
}
public IEnumerable <ProcessorItem> Process(IProcessorPipeline pipeline, IEnumerable <ProcessorItem> items)
{
return(items.Where(item => filter.Check(pipeline.Output, pipeline.PropertyProvider, pipeline.PropertyStore, item)));
}
