Beispiel #1
0
        private int OnCrossrefClear(CommandLineApplication cmd, CommandArgument argPath)
        {
            var paths = new[] { argPath.Value }
            .Concat(cmd.RemainingArguments)
            .Select(path => Path.GetFullPath(path))
            .ToArray();

            Console.WriteLine($"Executing Crossref Clear");

            var operations = new WorkspaceOperations();
            var workspace  = new DotnetWorkspace();

            foreach (var path in paths)
            {
                operations.FindAndLoadSolutions(workspace, path);
            }

            foreach (var solution in workspace.Solutions)
            {
                solution.GlobalJson.ClearAddedProjects();
            }

            foreach (var solution in workspace.Solutions)
            {
                solution.GlobalJson.Save();
            }

            return(0);
        }
        public void FindAndLoadSolutions(DotnetWorkspace workspace, string path)
        {
            var globalJsonMatches = new Matcher()
                                    .AddInclude("**/global.json")
                                    .Execute(new DirectoryInfoWrapper(new DirectoryInfo(path)));

            foreach (var file in globalJsonMatches.Files)
            {
                var globalJsonPath = Path.Combine(path, file.Path);

                Console.WriteLine($"Loading {globalJsonPath}");

                workspace.Solutions.Add(DotnetSolution.Load(globalJsonPath));
            }
        }
        public void FindProjectToProjectDependencies(DotnetWorkspace workspace)
        {
            foreach (var project in workspace.Projects)
            {
                foreach (var dependency in project.ProjectJson.Dependencies)
                {
                    var match = workspace.Projects.SingleOrDefault(p =>
                                                                   string.Equals(p.Name, dependency.Name, StringComparison.OrdinalIgnoreCase));

                    if (match != null)
                    {
                        project.Dependencies.Add(new DotnetProjectDependency
                        {
                            ProjectJsonDependency = dependency,
                            DotnetProject         = match,
                        });
                    }
                }
            }
        }
        public void FindAndLoadProjects2(DotnetWorkspace workspace)
        {
            foreach (var solution in workspace.Solutions)
            {
                var scanPath = solution.GlobalJson.FolderPath;

                var projectJsonMatches = new Matcher()
                                         .AddInclude("**/project.json")
                                         .Execute(new DirectoryInfoWrapper(new DirectoryInfo(scanPath)));

                foreach (var file in projectJsonMatches.Files)
                {
                    var projectJsonPath = Path.Combine(scanPath, file.Path);
                    Console.WriteLine($"  Loading {projectJsonPath}");

                    var project = DotnetProject.Load(projectJsonPath);
                    project.Solution = solution;
                    solution.Projects.Add(project);
                }
            }
        }
        public void FindAndLoadProjects1(DotnetWorkspace workspace)
        {
            foreach (var solution in workspace.Solutions)
            {
                if (!solution.GlobalJson.ProjectFolders.Any())
                {
                    Console.WriteLine($"NO 'projects' folders {solution.GlobalJson.FolderPath}");
                    continue;
                }
                foreach (var projectFolder in solution.GlobalJson.ProjectFolders)
                {
                    var scanPath = Path.Combine(solution.GlobalJson.FolderPath, projectFolder.Path);

                    if (!scanPath.StartsWith(solution.GlobalJson.FolderPath) ||
                        projectFolder.Path.StartsWith("."))
                    {
                        Console.WriteLine($"OUTSIDE FOLDER {solution.GlobalJson.FolderPath}:{projectFolder.Path}");
                        continue;
                    }

                    Console.WriteLine($"Scanning {solution.GlobalJson.FolderPath}:{projectFolder.Path}");

                    var projectJsonMatches = new Matcher()
                                             .AddInclude("*/project.json")
                                             .Execute(new DirectoryInfoWrapper(new DirectoryInfo(scanPath)));

                    foreach (var file in projectJsonMatches.Files)
                    {
                        var projectJsonPath = Path.Combine(scanPath, file.Path);
                        Console.WriteLine($"  Loading {projectJsonPath}");

                        var project = DotnetProject.Load(projectJsonPath);
                        project.Solution = solution;
                        solution.Projects.Add(project);
                    }
                }
            }
        }
Beispiel #6
0
        private int OnCrossrefAdd(
            CommandLineApplication cmd,
            CommandArgument argPath)
        {
            var paths = new[] { argPath.Value }
            .Concat(cmd.RemainingArguments)
            .Select(path => Path.GetFullPath(path))
            .ToArray();

            Console.WriteLine($"Executing Crossref Add");

            var operations = new WorkspaceOperations();
            var workspace  = new DotnetWorkspace();

            foreach (var path in paths)
            {
                operations.FindAndLoadSolutions(workspace, path);
            }
            operations.FindAndLoadProjects2(workspace);
            operations.FindProjectToProjectDependencies(workspace);

            foreach (var solution in workspace.Solutions)
            {
                var allProject = solution.Projects.Select(p => Tuple.Create(p, p, p));

                var allProject2Project = SelectRecursive(0, allProject);

                var allProject2ProjectLocations = allProject2Project
                                                  .Where(tuple => tuple.Item1.ProjectJson.ParentPath != tuple.Item3.ProjectJson.ParentPath)
                                                  .GroupBy(tuple => MakeRelativePath(solution.GlobalJson.FilePath, tuple.Item3.ProjectJson.ParentPath).Replace("\\", "/"))
                                                  .ToArray();

                var neededLocations = new List <string>();

//                Console.WriteLine($"  {solution.GlobalJson.FolderPath}");
                foreach (var project2ProjectLocation in allProject2ProjectLocations)
                {
                    neededLocations.Add(project2ProjectLocation.Key);
                    //                  Console.WriteLine($"    {project2ProjectLocation.Key}");
                    foreach (var dependencyName in project2ProjectLocation.Select(x => x.Item3.Name).Distinct())
                    {
                        //                    Console.WriteLine($"      {dependencyName}");
                    }
                }

                foreach (var neededLocation in neededLocations)
                {
                    if (!solution.GlobalJson.ProjectFolders.Any(pf =>
                                                                string.Equals(pf.Path, neededLocation, StringComparison.OrdinalIgnoreCase)))
                    {
                        solution.GlobalJson.AddProjectFolder(neededLocation);
                    }
                }
            }

            foreach (var solution in workspace.Solutions)
            {
                solution.GlobalJson.Save();
            }

            using (var batch = File.CreateText("restore-all.cmd"))
            {
                foreach (var p in workspace.Projects)
                {
                    batch.WriteLine($"call dnu restore {p.ProjectJson.FolderPath}");
                }
            }
            return(0);
        }