public IEnumerable <ContentItemGroup> FindItemGroups(PatternSet definition)
{
if (_assets.Count > 0)
{
var groupPatterns = definition.GroupExpressions;
List <Tuple <ContentItem, Asset> > groupAssets = null;
foreach (var asset in _assets)
{
foreach (var groupPattern in groupPatterns)
{
var item = groupPattern.Match(asset.Path, definition.PropertyDefinitions);
if (item != null)
{
if (groupAssets == null)
{
groupAssets = new List <Tuple <ContentItem, Asset> >(1);
}
groupAssets.Add(Tuple.Create(item, asset));
}
}
}
if (groupAssets?.Count > 0)
{
foreach (var grouping in groupAssets.GroupBy(key => key.Item1, GroupComparer.DefaultComparer))
{
var group = new ContentItemGroup();
foreach (var property in grouping.Key.Properties)
{
group.Properties.Add(property.Key, property.Value);
}
foreach (var item in FindItemsImplementation(definition, grouping.Select(match => match.Item2)))
{
group.Items.Add(item);
}
yield return(group);
}
}
}
}
/// <summary>
/// Populate the provided list with ContentItemGroups based on a provided pattern set.
/// </summary>
/// <param name="definition">The pattern set to match</param>
/// <param name="contentItemGroupList">The list that will be mutated and populated with the item groups</param>
public void PopulateItemGroups(PatternSet definition, IList <ContentItemGroup> contentItemGroupList)
{
if (_assets.Count > 0)
{
var groupPatterns = definition.GroupExpressions;
List <Tuple <ContentItem, Asset> > groupAssets = null;
foreach (var asset in _assets)
{
foreach (var groupPattern in groupPatterns)
{
var item = groupPattern.Match(asset.Path, definition.PropertyDefinitions);
if (item != null)
{
if (groupAssets == null)
{
groupAssets = new List <Tuple <ContentItem, Asset> >(1);
}
groupAssets.Add(Tuple.Create(item, asset));
}
}
}
IList <ContentItem> groupItems = new List <ContentItem>();
if (groupAssets?.Count > 0)
{
foreach (var grouping in groupAssets.GroupBy(key => key.Item1, GroupComparer.DefaultComparer))
{
var group = new ContentItemGroup();
foreach (var property in grouping.Key.Properties)
{
group.Properties.Add(property.Key, property.Value);
}
groupItems = FindItemsImplementation(definition, grouping.Select(match => match.Item2));
group.Items.AddRange(groupItems);
contentItemGroupList.Add(group);
}
}
}
}
public IEnumerable <ContentItemGroup> FindItemGroups(ContentPatternDefinition definition)
{
var groupPatterns = definition.GroupPatterns
.Select(pattern => Tuple.Create(pattern, new Infrastructure.PatternExpression(pattern.Pattern)))
.ToList();
var groupAssets = new List <Tuple <ContentItem, Asset> >();
foreach (var asset in _assets)
{
foreach (var groupParser in groupPatterns)
{
ContentItem item = groupParser.Item2.Match(asset.Path, definition.PropertyDefinitions);
if (item != null)
{
foreach (var pair in groupParser.Item1.Defaults)
{
item.Properties[pair.Key] = pair.Value;
}
groupAssets.Add(Tuple.Create(item, asset));
}
}
}
foreach (var grouping in groupAssets.GroupBy(key => key.Item1, new GroupComparer()))
{
var group = new ContentItemGroup();
foreach (var property in grouping.Key.Properties)
{
group.Properties.Add(property.Key, property.Value);
}
foreach (var item in FindItemsImplementation(definition, grouping.Select(match => match.Item2)))
{
group.Items.Add(item);
}
yield return(group);
}
}
public ContentItemGroup FindBestItemGroup(SelectionCriteria criteria, params ContentPatternDefinition[] definitions)
{
foreach (var definition in definitions)
{
var itemGroups = FindItemGroups(definition).ToList();
foreach (var criteriaEntry in criteria.Entries)
{
ContentItemGroup bestGroup = null;
var bestAmbiguity = false;
foreach (var itemGroup in itemGroups)
{
var groupIsValid = true;
foreach (var criteriaProperty in criteriaEntry.Properties)
{
if (criteriaProperty.Value == null)
{
if (itemGroup.Properties.ContainsKey(criteriaProperty.Key))
{
groupIsValid = false;
break;
}
}
else
{
object itemProperty;
if (!itemGroup.Properties.TryGetValue(criteriaProperty.Key, out itemProperty))
{
groupIsValid = false;
break;
}
ContentPropertyDefinition propertyDefinition;
if (!definition.PropertyDefinitions.TryGetValue(criteriaProperty.Key, out propertyDefinition))
{
groupIsValid = false;
break;
}
if (!propertyDefinition.IsCriteriaSatisfied(criteriaProperty.Value, itemProperty))
{
groupIsValid = false;
break;
}
}
}
if (groupIsValid)
{
if (bestGroup == null)
{
bestGroup = itemGroup;
}
else
{
var groupComparison = 0;
foreach (var criteriaProperty in criteriaEntry.Properties)
{
if (criteriaProperty.Value == null)
{
continue;
}
else
{
var bestGroupValue = bestGroup.Properties[criteriaProperty.Key];
var itemGroupValue = itemGroup.Properties[criteriaProperty.Key];
var propertyDefinition = definition.PropertyDefinitions[criteriaProperty.Key];
groupComparison = propertyDefinition.Compare(criteriaProperty.Value, bestGroupValue, itemGroupValue);
if (groupComparison != 0)
{
break;
}
}
}
if (groupComparison > 0)
{
bestGroup = itemGroup;
bestAmbiguity = false;
}
else if (groupComparison == 0)
{
bestAmbiguity = true;
}
}
}
}
if (bestGroup != null)
{
if (bestAmbiguity)
{
// TODO: Something
}
return(bestGroup);
}
}
}
return(null);
}
private IEnumerable<string> GetRuntimeAssetFoldersForPromotion(ContentItemGroup runtimeAssets, NuGetFramework targetFramework, string targetFrameworkName)
{
if (runtimeAssets == null || runtimeAssets.Items.Count == 0)
{
return Enumerable.Empty<string>();
}
if (runtimeAssets.Items.All(ci => NuGetAssetResolver.IsPlaceholder(ci.Path)))
{
return Enumerable.Empty<string>();
}
if (targetFrameworkName == null)
{
targetFrameworkName = targetFramework.GetShortFolderName();
}
var resolvedFramework = runtimeAssets.Properties["tfm"] as NuGetFramework;
if (targetFramework.Equals(resolvedFramework))
{
Log.LogMessage(LogImportance.Low, $"Not promoting explicit implementation for {targetFrameworkName}");
return Enumerable.Empty<string>();
}
return NuGetAssetResolver.GetPackageTargetDirectories(runtimeAssets);
}
private IEnumerable<string> GetObscuredAssetFolders(ContentItemGroup assets, ContentItemGroup obscuredAssets, NuGetFramework targetFramework, string targetFrameworkName, string expectedAssetFolder, string ignoredAssetFolder = null)
{
if (assets == null || assets.Items.Count == 0)
{
return Enumerable.Empty<string>();
}
if (assets.Items.Any(ci => !NuGetAssetResolver.IsPlaceholder(ci.Path)))
{
return Enumerable.Empty<string>();
}
if (targetFrameworkName == null)
{
targetFrameworkName = targetFramework.GetShortFolderName();
}
var resolvedFramework = assets.Properties["tfm"] as NuGetFramework;
if (targetFramework.Equals(resolvedFramework))
{
Log.LogMessage(LogImportance.Low, $"Not overriding explicit placeholder for {targetFrameworkName}");
return Enumerable.Empty<string>();
}
var obscuredAssetPaths = NuGetAssetResolver.GetPackageTargetDirectories(obscuredAssets);
if (ignoredAssetFolder != null)
{
string ignoredFolder = ignoredAssetFolder + '/';
obscuredAssetPaths = obscuredAssetPaths.Where(i => -1 == i.IndexOf(ignoredFolder, StringComparison.OrdinalIgnoreCase));
}
if (expectedAssetFolder != null)
{
var unexpectedAssetPaths = obscuredAssetPaths.Where(ri => !ri.StartsWith(expectedAssetFolder, StringComparison.OrdinalIgnoreCase));
foreach (var unexpectedAssetPath in unexpectedAssetPaths)
{
Log.LogWarning($"Unexpected targetPath {unexpectedAssetPath}. Expected only {expectedAssetFolder}.");
}
// filter after we've warned
obscuredAssetPaths = obscuredAssetPaths.Except(unexpectedAssetPaths);
}
if (!obscuredAssetPaths.Any())
{
// it's acceptable to have no override, this is the case for packages which
// carry implementation in a runtime-specific package
Log.LogMessage(LogImportance.Low, $"No {expectedAssetFolder} assets could be found to override inbox placeholder for {targetFrameworkName}.");
}
return obscuredAssetPaths;
}
public static IEnumerable<string> GetPackageTargetDirectories(ContentItemGroup contentGroup)
{
if (contentGroup == null)
{
yield break;
}
foreach (var contentItem in contentGroup.Items)
{
// package paths are standardized to '/'
int dirLength = contentItem.Path.LastIndexOf(Path.AltDirectorySeparatorChar);
if (dirLength == -1)
{
yield return "";
}
else
{
yield return contentItem.Path.Substring(0, dirLength);
}
}
}
