public CompatibilityProfileCacheEntry( CompatibilityProfileDataMut mutableProfileData, CompatibilityProfileData profile) { MutableProfileData = mutableProfileData; Profile = profile; }
/// <summary> /// Combine a list of compatibility profiles together so that any assembly, module, /// type, command, etc. available in one is listed in the final result. /// </summary> /// <param name="profileId">The profile ID to assign to the generated union profile.</param> /// <param name="profiles">The profiles to union together to generate the result.</param> /// <returns>The deep union of all the given profiles, with the configured ID.</returns> public static CompatibilityProfileData UnionMany(string profileId, IEnumerable <CompatibilityProfileData> profiles) { CompatibilityProfileData unionProfile = CombineProfiles(profiles, Union); unionProfile.Platform = null; unionProfile.Id = profileId; unionProfile.ConstituentProfiles = profiles.Select(p => p.Id).ToArray(); return(unionProfile); }
/// <summary> /// Deserialize a compatibility profile from a text reader object. /// </summary> /// <param name="textReader">The text reader to read JSON data from to hydrate the compatibility profile.</param> /// <returns>The hydrated compatibility profile as a .NET object.</returns> public CompatibilityProfileData Deserialize(TextReader textReader) { CompatibilityProfileData profile = _serializer.Deserialize <CompatibilityProfileData>(new JsonTextReader(textReader)); if (profile.ProfileSchemaVersion == null) { profile.ProfileSchemaVersion = new Version(1, 0); } return(profile); }
/// <summary> /// For a set of profile paths, retrieve those profiles, /// along with the union profile for comparison. /// </summary> /// <param name="profileDirPath">The absolute path to the profile directory.</param> /// <param name="profilePaths">Absolute paths to all profiles to load.</param> /// <param name="unionProfile">The loaded union profile to compare against.</param> /// <returns>A list of hydrated profiles from all the profile paths given, not necessarily in order.</returns> public IEnumerable <CompatibilityProfileData> GetProfilesWithUnion( DirectoryInfo profileDirPath, IEnumerable <string> profilePaths, out CompatibilityProfileData unionProfile) { Task <CompatibilityProfileCacheEntry[]> profileEntries = GetProfilesFromPaths(profilePaths); unionProfile = GetUnionProfile(profileDirPath).Result.Profile; return(profileEntries.Result.Select(p => p.Profile)); }
public TypeCompatibilityVisitor( string analyzedFileName, CompatibilityProfileData anyProfile, IEnumerable <CompatibilityProfileData> compatibilityTargetProfiles, IEnumerable <string> typesToIgnore, UseCompatibleTypes rule) { _analyzedFileName = analyzedFileName; _anyProfile = anyProfile; _compatibilityTargets = compatibilityTargetProfiles; _typesToIgnore = new HashSet <string>(typesToIgnore, StringComparer.OrdinalIgnoreCase); _rule = rule; _diagnosticAccumulator = new List <DiagnosticRecord>(); }
/// <summary> /// Call this method to load the compatibilty profiles configured for this rule. /// </summary> /// <returns>The any profile and a list of target profiles for this rule.</returns> protected IEnumerable <CompatibilityProfileData> LoadCompatibilityProfiles(out CompatibilityProfileData unionProfile) { if (TargetProfiles == null) { throw new InvalidOperationException($"{nameof(TargetProfiles)} cannot be null"); } if (TargetProfiles.Length == 0) { throw new InvalidOperationException($"{nameof(TargetProfiles)} cannot be empty"); } return(_profileLoader.GetProfilesWithUnion(_profileDir, TargetProfiles.Select(path => NormalizeProfileNameToAbsolutePath(path)), out unionProfile)); }
/// <summary> /// Load a profile from a path. /// Caches profiles based on path, so that repeated calls do not require JSON deserialization. /// </summary> /// <param name="path">The path to load a profile from.</param> /// <returns>A query object around the loaded profile.</returns> private Lazy <Task <CompatibilityProfileCacheEntry> > GetProfileFromPath(string path) { if (path == null) { throw new ArgumentNullException(nameof(path)); } return(_profileCache.GetOrAdd(path, new Lazy <Task <CompatibilityProfileCacheEntry> >(() => Task.Run(() => { CompatibilityProfileDataMut compatibilityProfileMut = _jsonSerializer.DeserializeFromFile(path); var compatibilityProfile = new CompatibilityProfileData(compatibilityProfileMut); return new CompatibilityProfileCacheEntry( compatibilityProfileMut, compatibilityProfile); })))); }
private void CheckCommandInvocationParameters( CompatibilityProfileData targetProfile, string commandName, CommandAst commandAst, IEnumerable <CommandData> commandsToCheck) { // TODO: // Ideally we would go through each command and emulate the parameter binding algorithm // to work out what positions and what parameters will and won't work, // but this is very involved. // For now, we'll just check that the parameters exist for (int i = 0; i < commandAst.CommandElements.Count; i++) { CommandElementAst commandElement = commandAst.CommandElements[i]; if (!(commandElement is CommandParameterAst parameterAst)) { continue; } bool isGoodParam = false; foreach (CommandData command in commandsToCheck) { if ((command.Parameters != null && command.Parameters.ContainsKey(parameterAst.ParameterName)) || (command.IsCmdletBinding && targetProfile.Runtime.Common.Parameters.ContainsKey(parameterAst.ParameterName))) { isGoodParam = true; break; } } if (isGoodParam) { continue; } _diagnosticAccumulator.Add(CommandCompatibilityDiagnostic.CreateForParameter( parameterAst.ParameterName, commandName, targetProfile.Platform, parameterAst.Extent, _analyzedFileName, _rule)); } }
private static CompatibilityProfileData CombineProfiles(IEnumerable <CompatibilityProfileData> profiles, Func <CompatibilityProfileData, CompatibilityProfileData, object> combinator) { IEnumerator <CompatibilityProfileData> profileEnumerator = profiles.GetEnumerator(); if (!profileEnumerator.MoveNext()) { return(null); } CompatibilityProfileData mutProfileBase = (CompatibilityProfileData)profileEnumerator.Current.Clone(); while (profileEnumerator.MoveNext()) { mutProfileBase = (CompatibilityProfileData)combinator(mutProfileBase, profileEnumerator.Current); } return(mutProfileBase); }
/// <inheritdoc/> public override bool IsProfileValid(Data.CompatibilityProfileData profileData, out IEnumerable <Exception> errors) { CompatibilityProfileData queryableProfile; try { queryableProfile = new CompatibilityProfileData(profileData); } catch (Exception e) { errors = new [] { e }; return(false); } try { _psVersionMajor = queryableProfile.Platform.PowerShell.Version.Major; ValidatePlatformData(queryableProfile.Id, queryableProfile.Platform); } catch (Exception e) { _errAcc.AddError(e); } try { ValidateRuntimeData(queryableProfile.Runtime); } catch (Exception e) { _errAcc.AddError(e); } if (_errAcc.HasErrors()) { errors = _errAcc.GetErrors(); return(false); } errors = null; return(true); }
private static object Union(CompatibilityProfileData thisProfile, CompatibilityProfileData thatProfile) { Union(thisProfile.Runtime, thatProfile.Runtime); return(thisProfile); }