Esempio n. 1
0
        public App()
        {
            InitializeComponent();

            /* Use default styles */
            ProjectStyle.Init(this);

            /* Use XAML styles in App.xaml file */
            //ProjectStyle.Init(this, "Style.Configuration");

            /* Use Custom styles configuration */
            //var customConfiguration = new StyleConfiguration
            //{
            //    ColorConfiguration = new ColorConfiguration
            //    {
            //        // Set properties
            //    },
            //    FontConfiguration = new FontConfiguration
            //    {
            //        // Set properties
            //    }
            //};
            //ProjectStyle.Init(this, customConfiguration);

            MainPage = new MainPage();
        }
Esempio n. 2
0
 public BaselineProject(UnconfiguredProject project, ImmutableArray <string> globalProperties, ProjectStyle projectStyle, ProjectOutputType outputType) : this()
 {
     GlobalProperties = globalProperties;
     Project          = project ?? throw new ArgumentNullException(nameof(project));
     ProjectStyle     = projectStyle;
     OutputType       = outputType;
 }
 public BaselineProject(UnconfiguredProject project, ImmutableArray <string> globalProperties, ImmutableDictionary <string, string> targetProjectProperties, ProjectStyle projectStyle) : this()
 {
     GlobalProperties        = globalProperties;
     TargetProjectProperties = targetProjectProperties;
     Project      = project ?? throw new ArgumentNullException(nameof(project));
     ProjectStyle = projectStyle;
 }
Esempio n. 4
0
        private static string AdjustTargetTFM(ProjectStyle projectStyle, ProjectOutputType outputType, string candidateTargetTFM)
        {
            if (candidateTargetTFM.ContainsIgnoreCase(MSBuildFacts.Net5) && projectStyle is ProjectStyle.WindowsDesktop)
            {
                return(MSBuildFacts.Net5Windows);
            }

            if (projectStyle is not ProjectStyle.MSTest && projectStyle is not ProjectStyle.Web && outputType is ProjectOutputType.Library)
            {
                return(MSBuildFacts.NetStandard20);
            }

            //conditional checks for Xamarin Project Styles
            if (projectStyle is ProjectStyle.XamarinDroid)
            {
                return(XamarinFacts.Net6XamarinAndroid);
            }

            if (projectStyle is ProjectStyle.XamariniOS)
            {
                return(XamarinFacts.Net6XamariniOS);
            }

            return(candidateTargetTFM);
        }
Esempio n. 5
0
 public RestoreResult(
     bool success,
     IEnumerable <RestoreTargetGraph> restoreGraphs,
     IEnumerable <CompatibilityCheckResult> compatibilityCheckResults,
     IEnumerable <MSBuildOutputFile> msbuildFiles,
     LockFile lockFile,
     LockFile previousLockFile,
     string lockFilePath,
     CacheFile cacheFile,
     string cacheFilePath,
     string packagesLockFilePath,
     PackagesLockFile packagesLockFile,
     string dependencyGraphSpecFilePath,
     DependencyGraphSpec dependencyGraphSpec,
     ProjectStyle projectStyle,
     TimeSpan elapsedTime)
 {
     Success                      = success;
     RestoreGraphs                = restoreGraphs;
     CompatibilityCheckResults    = compatibilityCheckResults;
     MSBuildOutputFiles           = msbuildFiles;
     LockFile                     = lockFile;
     LockFilePath                 = lockFilePath;
     PreviousLockFile             = previousLockFile;
     CacheFile                    = cacheFile;
     CacheFilePath                = cacheFilePath;
     _newPackagesLockFilePath     = packagesLockFilePath;
     _newPackagesLockFile         = packagesLockFile;
     _dependencyGraphSpecFilePath = dependencyGraphSpecFilePath;
     _dependencyGraphSpec         = dependencyGraphSpec;
     ProjectStyle                 = projectStyle;
     ElapsedTime                  = elapsedTime;
 }
        protected override IProjectContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options)
        {
            NuGetProjectKind projectKind  = NuGetProjectKind.Unknown;
            ProjectStyle     projectStyle = ProjectStyle.Unknown;
            string?          projectId    = null;

            int propertyCount = reader.ReadMapHeader();

            for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
            {
                switch (reader.ReadString())
                {
                case ProjectIdPropertyName:
                    projectId = reader.ReadString();
                    break;

                case ProjectKindPropertyName:
                    projectKind = options.Resolver.GetFormatter <NuGetProjectKind>().Deserialize(ref reader, options);
                    break;

                case ProjectStylePropertyName:
                    projectStyle = options.Resolver.GetFormatter <ProjectStyle>().Deserialize(ref reader, options);
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }

            Assumes.NotNull(projectId);

            return(new ProjectContextInfo(projectId, projectStyle, projectKind));
        }
Esempio n. 7
0
 /// <summary>
 /// Create a library for a project.
 /// </summary>
 public static LockFileTargetLibrary CreateLockFileTargetProject(
     GraphItem <RemoteResolveResult> graphItem,
     LibraryIdentity library,
     LibraryIncludeFlags dependencyType,
     RestoreTargetGraph targetGraph,
     ProjectStyle rootProjectStyle)
 {
     return(CreateLockFileTargetProject(graphItem, library, dependencyType, targetGraph, rootProjectStyle, maccatalystFallback: null));
 }
Esempio n. 8
0
 public BaselineProject(UnconfiguredProject project, ImmutableArray <string> globalProperties, ProjectStyle projectStyle, ProjectOutputType outputType, string candidateTargetTFM, bool keepCurrentTFMs) : this()
 {
     GlobalProperties = globalProperties;
     Project          = project ?? throw new ArgumentNullException(nameof(project));
     ProjectStyle     = projectStyle;
     OutputType       = outputType;
     TargetTFM        = keepCurrentTFMs
         ? GetCurrentTFM(globalProperties, project)
         : AdjustTargetTFM(projectStyle, outputType, candidateTargetTFM);
 }
        static bool CanCachePackageSpec(PackageSpec packageSpec)
        {
            if (packageSpec.RestoreMetadata == null)
            {
                return(false);
            }

            ProjectStyle style = packageSpec.RestoreMetadata.ProjectStyle;

            return(style == ProjectStyle.PackageReference ||
                   style == ProjectStyle.ProjectJson ||
                   style == ProjectStyle.PackagesConfig);
        }
Esempio n. 10
0
        public void HashCode_WithProjectStyle(ProjectStyle left, ProjectStyle right, bool expected)
        {
            var leftSide = new ProjectRestoreMetadata
            {
                ProjectStyle = left
            };
            var rightSide = new ProjectRestoreMetadata
            {
                ProjectStyle = right
            };

            AssertHashCode(expected, leftSide, rightSide);
        }
Esempio n. 11
0
        public void Equals_WithProjectStyle(ProjectStyle left, ProjectStyle right, bool expected)
        {
            var leftSide = new ProjectRestoreMetadata
            {
                ProjectStyle = left
            };
            var rightSide = new ProjectRestoreMetadata
            {
                ProjectStyle = right
            };

            AssertEquality(expected, leftSide, rightSide);
        }
Esempio n. 12
0
        private static string AdjustTargetTFM(ProjectStyle projectStyle, ProjectOutputType outputType, string candidateTargetTFM)
        {
            if (candidateTargetTFM.ContainsIgnoreCase(MSBuildFacts.Net5) && projectStyle is ProjectStyle.WindowsDesktop)
            {
                return(MSBuildFacts.Net5Windows);
            }

            if (projectStyle is not ProjectStyle.MSTest && outputType is ProjectOutputType.Library)
            {
                return(MSBuildFacts.NetStandard20);
            }

            return(candidateTargetTFM);
        }
Esempio n. 13
0
        public static ValueTask <IProjectContextInfo> CreateAsync(NuGetProject nugetProject, CancellationToken cancellationToken)
        {
            Assumes.NotNull(nugetProject);

            if (!nugetProject.TryGetMetadata(NuGetProjectMetadataKeys.ProjectId, out string projectId))
            {
                throw new InvalidOperationException();
            }

            NuGetProjectKind projectKind  = GetProjectKind(nugetProject);
            ProjectStyle     projectStyle = nugetProject.ProjectStyle;

            return(new ValueTask <IProjectContextInfo>(new ProjectContextInfo(projectId, projectStyle, projectKind)));
        }
Esempio n. 14
0
        public IProjectContextInfo?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
        {
            if (reader.TryReadNil())
            {
                return(null);
            }

            // stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
            options.Security.DepthStep(ref reader);

            try
            {
                NuGetProjectKind projectKind  = NuGetProjectKind.Unknown;
                ProjectStyle     projectStyle = ProjectStyle.Unknown;
                string?          projectId    = null;

                int propertyCount = reader.ReadMapHeader();
                for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
                {
                    switch (reader.ReadString())
                    {
                    case ProjectIdPropertyName:
                        projectId = reader.ReadString();
                        break;

                    case ProjectKindPropertyName:
                        projectKind = options.Resolver.GetFormatter <NuGetProjectKind>().Deserialize(ref reader, options);
                        break;

                    case ProjectStylePropertyName:
                        projectStyle = options.Resolver.GetFormatter <ProjectStyle>().Deserialize(ref reader, options);
                        break;

                    default:
                        reader.Skip();
                        break;
                    }
                }

                Assumes.NotNull(projectId);

                return(new ProjectContextInfo(projectId, projectStyle, projectKind));
            }
            finally
            {
                // stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
                reader.Depth--;
            }
        }
Esempio n. 15
0
        public HashSet <PackageReferenceInfo> LoadPackageReferences(IEnumerable <ProjectAnalyzer> projects)
        {
            var results = new HashSet <PackageReferenceInfo>();

            foreach (var project in projects)
            {
                _ui.ReportMedium(() => $"Checking package references: {Path.GetFileName(project.ProjectFile.Path)}");

                var projectStyle    = ProjectStyle.Create(_ui, project);
                var projectPackages = projectStyle.LoadPackageReferences();

                results.UnionWith(projectPackages);
            }

            return(results);
        }
Esempio n. 16
0
 public RestoreResult(
     bool success,
     IEnumerable <RestoreTargetGraph> restoreGraphs,
     IEnumerable <CompatibilityCheckResult> compatibilityCheckResults,
     IEnumerable <MSBuildOutputFile> msbuildFiles,
     LockFile lockFile,
     LockFile previousLockFile,
     string lockFilePath,
     ProjectStyle projectStyle,
     TimeSpan elapsedTime)
 {
     Success                   = success;
     RestoreGraphs             = restoreGraphs;
     CompatibilityCheckResults = compatibilityCheckResults;
     MSBuildOutputFiles        = msbuildFiles;
     LockFile                  = lockFile;
     LockFilePath              = lockFilePath;
     PreviousLockFile          = previousLockFile;
     ProjectStyle              = projectStyle;
     ElapsedTime               = elapsedTime;
 }
        public override bool Execute()
        {
            var log = new MSBuildLogger(Log);

            // Log Inputs
            BuildTasksUtility.LogInputParam(log, nameof(HasPackageReferenceItems), HasPackageReferenceItems.ToString());
            BuildTasksUtility.LogInputParam(log, nameof(MSBuildProjectDirectory), MSBuildProjectDirectory);
            BuildTasksUtility.LogInputParam(log, nameof(MSBuildProjectName), MSBuildProjectName);
            BuildTasksUtility.LogInputParam(log, nameof(ProjectJsonPath), ProjectJsonPath);
            BuildTasksUtility.LogInputParam(log, nameof(RestoreProjectStyle), RestoreProjectStyle);

            var result = BuildTasksUtility.GetProjectRestoreStyle(RestoreProjectStyle, HasPackageReferenceItems, ProjectJsonPath, MSBuildProjectDirectory, MSBuildProjectName, log);

            IsPackageReferenceCompatibleProjectStyle = result.IsPackageReferenceCompatibleProjectStyle;
            ProjectStyle = result.ProjectStyle;

            // Log Outputs
            BuildTasksUtility.LogOutputParam(log, nameof(IsPackageReferenceCompatibleProjectStyle), IsPackageReferenceCompatibleProjectStyle.ToString());
            BuildTasksUtility.LogOutputParam(log, nameof(ProjectStyle), ProjectStyle.ToString());

            return(!Log.HasLoggedErrors);
        }
Esempio n. 18
0
        private static IEnumerable <TargetFrameworkInformation> GetTargetFrameworkInformation(string filePath, ProjectStyle restoreType, IEnumerable <IMSBuildItem> items)
        {
            var uniqueIds = new HashSet <string>();

            foreach (var item in GetItemByType(items, "TargetFrameworkInformation"))
            {
                var frameworkString          = item.GetProperty("TargetFramework");
                var targetFrameworkMoniker   = item.GetProperty("TargetFrameworkMoniker");
                var targetPlatforMoniker     = item.GetProperty("TargetPlatformMoniker");
                var targetPlatformMinVersion = item.GetProperty("TargetPlatformMinVersion");
                var clrSupport  = item.GetProperty("CLRSupport");
                var targetAlias = string.IsNullOrEmpty(frameworkString) ? string.Empty : frameworkString;
                if (uniqueIds.Contains(targetAlias))
                {
                    continue;
                }
                uniqueIds.Add(targetAlias);

                NuGetFramework targetFramework = MSBuildProjectFrameworkUtility.GetProjectFramework(
                    projectFilePath: filePath,
                    targetFrameworkMoniker: targetFrameworkMoniker,
                    targetPlatformMoniker: targetPlatforMoniker,
                    targetPlatformMinVersion: targetPlatformMinVersion,
                    clrSupport: clrSupport);

                var targetFrameworkInfo = new TargetFrameworkInformation()
                {
                    FrameworkName = targetFramework,
                    TargetAlias   = targetAlias
                };
                if (restoreType == ProjectStyle.PackageReference ||
                    restoreType == ProjectStyle.Standalone ||
                    restoreType == ProjectStyle.DotnetToolReference)
                {
                    var packageTargetFallback = MSBuildStringUtility.Split(item.GetProperty("PackageTargetFallback"))
                                                .Select(NuGetFramework.Parse)
                                                .ToList();

                    var assetTargetFallback = MSBuildStringUtility.Split(item.GetProperty(AssetTargetFallbackUtility.AssetTargetFallback))
                                              .Select(NuGetFramework.Parse)
                                              .ToList();

                    // Throw if an invalid combination was used.
                    AssetTargetFallbackUtility.EnsureValidFallback(packageTargetFallback, assetTargetFallback, filePath);

                    // Update the framework appropriately
                    AssetTargetFallbackUtility.ApplyFramework(targetFrameworkInfo, packageTargetFallback, assetTargetFallback);

                    targetFrameworkInfo.RuntimeIdentifierGraphPath = item.GetProperty("RuntimeIdentifierGraphPath");
                }
                yield return(targetFrameworkInfo);
            }
        }
Esempio n. 19
0
        /// <summary>
        /// Convert MSBuild items to a PackageSpec.
        /// </summary>
        public static PackageSpec GetPackageSpec(IEnumerable <IMSBuildItem> items)
        {
            if (items == null)
            {
                throw new ArgumentNullException(nameof(items));
            }

            PackageSpec result = null;

            // There should only be one ProjectSpec per project in the item set,
            // but if multiple do appear take only the first one in an effort
            // to handle this gracefully.
            var specItem = GetItemByType(items, "projectSpec").FirstOrDefault();

            if (specItem != null)
            {
                ProjectStyle restoreType   = GetProjectStyle(specItem);
                bool         isCpvmEnabled = IsCentralVersionsManagementEnabled(specItem, restoreType);

                // Get base spec
                if (restoreType == ProjectStyle.ProjectJson)
                {
                    result = GetProjectJsonSpec(specItem);
                }
                else
                {
                    // Read msbuild data for PR and related projects
                    result = GetBaseSpec(specItem, restoreType, items);
                }

                // Applies to all types
                result.RestoreMetadata.ProjectStyle      = restoreType;
                result.RestoreMetadata.ProjectPath       = specItem.GetProperty("ProjectPath");
                result.RestoreMetadata.ProjectUniqueName = specItem.GetProperty("ProjectUniqueName");

                if (string.IsNullOrEmpty(result.Name))
                {
                    result.Name = result.RestoreMetadata.ProjectName
                                  ?? result.RestoreMetadata.ProjectUniqueName
                                  ?? Path.GetFileNameWithoutExtension(result.FilePath);
                }

                // Read project references for all
                AddProjectReferences(result, items);

                if (restoreType == ProjectStyle.PackageReference ||
                    restoreType == ProjectStyle.Standalone ||
                    restoreType == ProjectStyle.DotnetCliTool ||
                    restoreType == ProjectStyle.ProjectJson ||
                    restoreType == ProjectStyle.DotnetToolReference ||
                    restoreType == ProjectStyle.PackagesConfig)
                {
                    foreach (var source in MSBuildStringUtility.Split(specItem.GetProperty("Sources")))
                    {
                        // Fix slashes incorrectly removed by MSBuild
                        var pkgSource = new PackageSource(FixSourcePath(source));
                        result.RestoreMetadata.Sources.Add(pkgSource);
                    }

                    foreach (var configFilePath in MSBuildStringUtility.Split(specItem.GetProperty("ConfigFilePaths")))
                    {
                        result.RestoreMetadata.ConfigFilePaths.Add(configFilePath);
                    }

                    foreach (var folder in MSBuildStringUtility.Split(specItem.GetProperty("FallbackFolders")))
                    {
                        result.RestoreMetadata.FallbackFolders.Add(folder);
                    }

                    result.RestoreMetadata.PackagesPath = specItem.GetProperty("PackagesPath");
                    result.RestoreMetadata.OutputPath   = specItem.GetProperty("OutputPath");
                }

                // Read package references for netcore, tools, and standalone
                if (restoreType == ProjectStyle.PackageReference ||
                    restoreType == ProjectStyle.Standalone ||
                    restoreType == ProjectStyle.DotnetCliTool ||
                    restoreType == ProjectStyle.DotnetToolReference)
                {
                    AddPackageReferences(result, items, isCpvmEnabled);
                    AddPackageDownloads(result, items);
                    AddFrameworkReferences(result, items);

                    // Store the original framework strings for msbuild conditionals
                    result.TargetFrameworks.ForEach(tfi =>
                                                    result.RestoreMetadata.OriginalTargetFrameworks.Add(
                                                        !string.IsNullOrEmpty(tfi.TargetAlias) ?
                                                        tfi.TargetAlias :
                                                        tfi.FrameworkName.GetShortFolderName()));
                }

                if (restoreType == ProjectStyle.PackageReference ||
                    restoreType == ProjectStyle.Standalone ||
                    restoreType == ProjectStyle.DotnetToolReference)
                {
                    // Set project version
                    result.Version = GetVersion(specItem);

                    // Add RIDs and Supports
                    result.RuntimeGraph = GetRuntimeGraph(specItem);

                    // Add CrossTargeting flag
                    result.RestoreMetadata.CrossTargeting = IsPropertyTrue(specItem, "CrossTargeting");

                    // Add RestoreLegacyPackagesDirectory flag
                    result.RestoreMetadata.LegacyPackagesDirectory = IsPropertyTrue(
                        specItem,
                        "RestoreLegacyPackagesDirectory");

                    // ValidateRuntimeAssets compat check
                    result.RestoreMetadata.ValidateRuntimeAssets = IsPropertyTrue(specItem, "ValidateRuntimeAssets");

                    // True for .NETCore projects.
                    result.RestoreMetadata.SkipContentFileWrite = IsPropertyTrue(specItem, "SkipContentFileWrite");

                    // Warning properties
                    result.RestoreMetadata.ProjectWideWarningProperties = GetWarningProperties(specItem);

                    // Packages lock file properties
                    result.RestoreMetadata.RestoreLockProperties = GetRestoreLockProperites(specItem);
                }

                if (restoreType == ProjectStyle.PackagesConfig)
                {
                    var pcRestoreMetadata = (PackagesConfigProjectRestoreMetadata)result.RestoreMetadata;
                    // Packages lock file properties
                    pcRestoreMetadata.PackagesConfigPath = specItem.GetProperty("PackagesConfigPath");
                    pcRestoreMetadata.RepositoryPath     = specItem.GetProperty("RepositoryPath");
                    var solutionDir = specItem.GetProperty("SolutionDir");
                    if (string.IsNullOrEmpty(pcRestoreMetadata.RepositoryPath) && !string.IsNullOrEmpty(solutionDir) && solutionDir != "*Undefined*")
                    {
                        pcRestoreMetadata.RepositoryPath = Path.Combine(
                            solutionDir,
                            "packages"
                            );
                    }
                    pcRestoreMetadata.RestoreLockProperties = GetRestoreLockProperites(specItem);
                }

                if (restoreType == ProjectStyle.ProjectJson)
                {
                    // Check runtime assets by default for project.json
                    result.RestoreMetadata.ValidateRuntimeAssets = true;
                }

                result.RestoreMetadata.CentralPackageVersionsEnabled = isCpvmEnabled;
            }

            return(result);
        }
Esempio n. 20
0
 internal static bool IsCentralVersionsManagementEnabled(IMSBuildItem projectSpecItem, ProjectStyle projectStyle)
 {
     return(IsPropertyTrue(projectSpecItem, "_CentralPackageVersionsEnabled") && projectStyle == ProjectStyle.PackageReference);
 }
Esempio n. 21
0
 public NoOpRestoreResult(bool success, string lockFilePath, Lazy <LockFile> lockFileLazy, CacheFile cacheFile, string cacheFilePath, ProjectStyle projectStyle, TimeSpan elapsedTime) :
     base(success: success, restoreGraphs: null, compatibilityCheckResults: new List <CompatibilityCheckResult>(),
          msbuildFiles: null, lockFile: null, previousLockFile: null, lockFilePath: lockFilePath,
          cacheFile: cacheFile, cacheFilePath: cacheFilePath, packagesLockFilePath: null, packagesLockFile: null, dependencyGraphSpecFilePath: null, dependencyGraphSpec: null, projectStyle: projectStyle, elapsedTime: elapsedTime)
 {
     _lockFileLazy = lockFileLazy ?? throw new ArgumentNullException(nameof(lockFileLazy));
 }