public ItemAction(string line, bool ignoreCase, string fullConfigFileName, int startLineNo)
{
Match match = Regex.Match(line ?? "", PATTERN_PATTERN);
if (!match.Success)
{
throw new ArgumentException(
$"Invalid item-action '{line}' at {fullConfigFileName}/{startLineNo}");
}
else
{
GroupCollection groups = match.Groups;
if (groups[1].Value != "")
{
_atLeastOneIncomingDependencyPattern = new DependencyPattern(groups[1].Value, ignoreCase);
}
if (groups[2].Value != "")
{
_itemMatch = new ItemMatch(groups[2].Value, ignoreCase, anyWhereMatcherOk: false);
}
if (groups[3].Value != "")
{
_atLeastOneOutgoingDependencyPattern = new DependencyPattern(groups[3].Value, ignoreCase);
}
if (groups[4].Value != "-" && groups[4].Value != "delete")
{
var effects = new List <Action <Item> >();
var effectOptions =
groups[4].Value.Split(' ', ',').Select(s => s.Trim()).Where(s => !string.IsNullOrWhiteSpace(s));
foreach (var effect in effectOptions)
{
if (effect == "" || effect == "ignore" || effect == "keep")
{
effects.Add(d => { });
}
else if (effect.StartsWith("+"))
{
effects.Add(i => i.IncrementMarker(effect.Substring(1)));
}
else if (effect.StartsWith("-"))
{
effects.Add(i => i.RemoveMarkers(effect.Substring(1), ignoreCase));
}
else
{
throw new ArgumentException(
$"Unexpected item directive '{effect}' at {fullConfigFileName}/{startLineNo}");
}
}
_effects = effects;
}
else
{
_effects = null;
}
}
}
private void AddPattern()
{
if (Patterns == null)
{
Patterns = new ObservableCollection <DependencyPattern>();
}
else
{
Patterns.Add(DependencyPattern.Create());
}
}
private void RemovePattern(DependencyPattern param)
{
if (Patterns == null)
{
return;
}
Patterns.Remove(param);
if (Patterns.Count == 0)
{
Patterns = null;
}
}
private void RecursivelyFlood(Item root, Item from, HashSet <Item> visited, Dictionary <FromTo, Dependency> checkPresence,
DependencyPattern idempotentPattern, Dictionary <Item, Dependency[]> outgoing, IEnumerable <ItemMatch> toItemMatches,
List <DependencyMatch> matches, List <DependencyMatch> excludes, Dictionary <string, int> markersToAddOrNull,
List <Dependency> result, Dependency collectedEdge, [NotNull] Action checkAbort, WorkingGraph workingGraph, bool ignoreCase)
{
if (outgoing.ContainsKey(from))
{
checkAbort();
foreach (var d in outgoing[from].Where(d => d.IsMarkerMatch(matches, excludes)))
{
Item target = d.UsedItem;
if (visited.Add(target))
{
Dependency rootToTarget = collectedEdge == null
? d
: workingGraph.CreateDependency(root, target, d.Source,
new MutableMarkerSet(ignoreCase,
markersToAddOrNull
?? MutableMarkerSet.ConcatOrUnionWithMarkers(collectedEdge.AbstractMarkerSet,
d.AbstractMarkerSet, ignoreCase)),
collectedEdge.Ct + d.Ct, collectedEdge.QuestionableCt + d.QuestionableCt,
collectedEdge.BadCt + d.BadCt, collectedEdge.NotOkReason ?? d.NotOkReason, d.ExampleInfo);
if (IsMatch(toItemMatches, target))
{
Dependency alreadyThere;
var rootTargetKey = new FromTo(root, target);
if (checkPresence.TryGetValue(rootTargetKey, out alreadyThere) && idempotentPattern.IsMatch(alreadyThere))
{
// we do not add a dependency
}
else
{
checkPresence[rootTargetKey] = rootToTarget;
result.Add(rootToTarget);
}
}
// Continue search
RecursivelyFlood(root, target, visited, checkPresence, idempotentPattern, outgoing,
toItemMatches, matches, excludes, markersToAddOrNull, result, rootToTarget,
checkAbort, workingGraph, ignoreCase);
}
}
}
}
public override int Transform([NotNull] GlobalContext globalContext, Ignore Ignore,
[NotNull] TransformOptions transformOptions, [NotNull][ItemNotNull] IEnumerable <Dependency> dependencies,
[NotNull] List <Dependency> transformedDependencies)
{
DependencyPattern idempotentPattern = transformOptions.MarkerToAdd == null ? null : new DependencyPattern("'" + transformOptions.MarkerToAdd, globalContext.IgnoreCase);
Dictionary <FromTo, Dependency> fromTos = transformOptions.Idempotent ? FromTo.AggregateAllDependencies(globalContext.CurrentGraph, dependencies) : null;
int added = 0;
int removed = 0;
foreach (var d in dependencies)
{
if (!transformOptions.RemoveOriginal)
{
transformedDependencies.Add(d);
}
else
{
removed++;
}
if (d.IsMarkerMatch(transformOptions.Matches, transformOptions.Excludes))
{
if (fromTos == null ||
!FromTo.ContainsMatchingDependency(fromTos, d.UsedItem, d.UsingItem, idempotentPattern))
{
var newDependency = globalContext.CurrentGraph.CreateDependency(d.UsedItem, d.UsingItem, d.Source, d.MarkerSet, d.Ct,
d.QuestionableCt, d.BadCt, d.NotOkReason, d.ExampleInfo);
if (transformOptions.MarkerToAdd != null)
{
newDependency.IncrementMarker(transformOptions.MarkerToAdd);
}
transformedDependencies.Add(newDependency);
added++;
}
}
}
Log.WriteInfo($"... added {added}{(removed > 0 ? " removed " + removed : "")} dependencies");
return(Program.OK_RESULT);
}
public override int Transform([NotNull] GlobalContext globalContext, Ignore Ignore,
[NotNull] TransformOptions transformOptions, [NotNull][ItemNotNull] IEnumerable <Dependency> dependencies,
[NotNull] List <Dependency> transformedDependencies)
{
_transformRunCt++;
MutableMarkerSet.AddComputedMarkerIfNoMarkers(transformOptions.MarkersToAdd,
transformOptions.FromItemMatches, transformOptions.ToItemMatches, "" + _transformRunCt);
WorkingGraph currentWorkingGraph = globalContext.CurrentGraph;
DependencyPattern idempotentPattern = new DependencyPattern("'" + string.Join("+", transformOptions.MarkersToAdd), globalContext.IgnoreCase);
Dictionary <FromTo, Dependency> checkPresence = transformOptions.Idempotent
? FromTo.AggregateAllDependencies(currentWorkingGraph, dependencies)
: new Dictionary <FromTo, Dependency>();
Dictionary <Item, Dependency[]> outgoing = Item.CollectOutgoingDependenciesMap(dependencies);
IEnumerable <Item> matchingFroms = outgoing.Keys.Where(i => IsMatch(transformOptions.FromItemMatches, i));
Dictionary <string, int> markersToAddAsDictionary = transformOptions.MarkersToAdd.Distinct().ToDictionary(s => s, s => 1);
var result = new List <Dependency>();
foreach (var from in matchingFroms)
{
RecursivelyFlood(from, from, new HashSet <Item> {
from
}, checkPresence, idempotentPattern, outgoing,
transformOptions.ToItemMatches, transformOptions.Matches, transformOptions.Excludes,
markersToAddAsDictionary, result, null, globalContext.CheckAbort,
currentWorkingGraph, globalContext.IgnoreCase);
}
transformedDependencies.AddRange(dependencies);
transformedDependencies.AddRange(result);
Log.WriteInfo($"... added {result.Count} new dependencies");
return(Program.OK_RESULT);
}
private static void PatternsListAdd(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var uc = d as DependencyPatternsUserControl;
if (uc == null)
{
return;
}
var firstItem = (e.NewValue as ObservableCollection <DependencyPattern>)?.FirstOrDefault();
if (firstItem == null && e.NewValue != null)
{
firstItem = DependencyPattern.Create();
{
uc.Patterns.Add(firstItem);
uc.SelectedPattern = firstItem;
}
}
else
{
uc.SelectedPattern = firstItem;
}
}