public PublishRepository(ISiteBuilder builder, ICompileService compileService, ProjectFinder projectFinder, IProcessRunner processRunner)
{
this.builder = builder;
this.compileService = compileService;
this.projectFinder = projectFinder;
this.processRunner = processRunner;
}
/// <summary>
/// The claims for the user logging in.
/// </summary>
/// <returns></returns>
private IEnumerable <Claim> AllClaims(ProjectFinder projectFinder)
{
//Open the project repo and read the global git settings to get the user info, if that is not found
//use UnconfiguredUser as the user name.
var projectLocation = projectFinder.MasterRepoPath;
var user = "******";
if (Directory.Exists(projectLocation))
{
using (var repo = new Repository(Repository.Discover(projectLocation)))
{
user = repo.Config.GetValueOrDefault <String>("user.name") ?? user;
var email = repo.Config.GetValueOrDefault <String>("user.email");
if (email != null)
{
yield return(new Claim("email", email));
}
}
}
yield return(new Claim("name", user));
yield return(new Claim("role", Roles.EditPages));
yield return(new Claim("role", Roles.Compile));
yield return(new Claim("role", Roles.UploadAnything));
yield return(new Claim("role", Roles.CreateDrafts));
yield return(new Claim("role", Roles.AddBranch));
yield return(new Claim("role", LocalEdityRoles.Shutdown));
}
public DraftRepository(IFileFinder fileFinder, ITargetFileInfoProvider fileInfoProvider, ProjectFinder projectFinder, IPathBaseInjector pathBaseInjector)
{
this.fileFinder = fileFinder;
this.fileInfoProvider = fileInfoProvider;
this.projectFinder = projectFinder;
this.pathBase = pathBaseInjector.PathBase;
}
public async Task UpdateSolutionAsync(string solutionPath, bool includePreviews = false, bool includeReleaseCandidates = false, bool switchToStable = false, bool checkAll = false, string version = null)
{
var projectPaths = ProjectFinder.GetProjectFiles(solutionPath);
if (checkAll && version.IsNullOrWhiteSpace())
{
Task.WaitAll(projectPaths.Select(projectPath => UpdateInternalAsync(projectPath, includePreviews, includeReleaseCandidates, switchToStable)).ToArray());
}
else
{
var latestVersionFromNuget = await _nuGetService.GetLatestVersionOrNullAsync("Volo.Abp.Core", includeReleaseCandidates : includeReleaseCandidates);
var latestReleaseCandidateVersionFromNuget = await _nuGetService.GetLatestVersionOrNullAsync("Volo.Abp.Core", includeReleaseCandidates : true);
var latestVersionFromMyGet = await GetLatestVersionFromMyGet("Volo.Abp.Core");
async Task UpdateAsync(string filePath)
{
var fileContent = File.ReadAllText(filePath);
var updatedContent = await UpdateVoloPackagesAsync(fileContent,
includePreviews,
includeReleaseCandidates,
switchToStable,
latestVersionFromNuget,
latestReleaseCandidateVersionFromNuget,
latestVersionFromMyGet,
version);
File.WriteAllText(filePath, updatedContent);
}
Task.WaitAll(projectPaths.Select(UpdateAsync).ToArray());
}
}
/// <summary>
/// Updates the versions of the projects.
/// </summary>
/// <param name="context"></param>
/// <param name="changeVersion"></param>
/// <returns></returns>
protected async Task <int> UpdateAsync(CommandContext context, Func <SemVersion, SemVersion> changeVersion)
{
context.WriteDebug("Updating versions...");
var finder = new ProjectFinder(context.Directory);
var projectFiles = finder.FindProjects();
foreach (var projectFile in projectFiles)
{
var project = _store.Read(projectFile);
context.NewVesion = UpdateProject(project, changeVersion);
_store.Save(project);
}
if (!string.IsNullOrEmpty(context.Message))
{
if (!await CommitAsync(context))
{
context.WriteWarning("Failed to commit.");
return(projectFiles.Count);
}
context.WriteInfo($"Commit \"{context.Message}\" is created.");
}
if (context.Tag)
{
if (!await AddTagAsync(context))
{
context.WriteWarning("Failed to add tag.");
return(projectFiles.Count);
}
context.WriteInfo($"Tag v{context.NewVesion} is added");
}
return(projectFiles.Count);
}
protected static void PerformBuild(ProjectFinder projectFinder, BuildDependencyInfo dependencyInfo, OptionValues optionValues)
{
foreach (var solutionFileName in dependencyInfo.TrimmedSolutionDependencyGraph.TopologicalSort())
{
Builder.BuildSolution(projectFinder, solutionFileName, optionValues.MatchingAssemblyRegexes, optionValues.FlipIgnore, optionValues.IgnoreMissingAssemblies, optionValues.CleanBeforeBuild, optionValues.RunTests, optionValues.IgnoreFailedTests);
}
}
public async Task <IActionResult> LogIn([FromServices] ProjectFinder projectFinder, String returnUrl)
{
var identity = new ClaimsIdentity(AllClaims(projectFinder), AuthCoreSchemes.Bearer, "name", "role");
await HttpContext.SignInAsync(AuthCoreSchemes.Bearer, new ClaimsPrincipal(identity));
return(SafeRedirect(ref returnUrl));
}
public void GetAssemblyName_Tests()
{
var assemblyName = ProjectFinder.GetAssemblyName(
GetNormalizedPath(
@"c:\temp\project\folder\src\Acme.PhoneBook.Host.csproj"
)
);
assemblyName.ShouldBe("Acme.PhoneBook.Host");
}
public void FindWithNoProjectOrSolution()
{
using (var fs = new DisposableFileSystem())
{
fs.CreateFolder("src/project1")
.CreateFile("src/project1/project1.csproj");
var finder = new ProjectFinder(fs.RootPath);
Assert.Throws <FileNotFoundException>(() => finder.FindProjects());
}
}
public void Execute(CommandContext context)
{
var reader = new ProjectStore();
var finder = new ProjectFinder(context.Directory);
var projectFiles = finder.FindProjects();
foreach (var projectFile in projectFiles)
{
var project = reader.Read(projectFile);
context.WriteInfo($"\t{project.Name} -> {project.Version}");
}
}
public bool Run(bool preview)
{
Log.Information($"Task: {_taskCreator.Description}");
UpdateProjectOptions options = _project.Options;
ProjectFinder projectFinder = new ProjectFinder();
ProjectUpdater projectUpdater = new ProjectUpdater();
bool atLeastOneUpdated = false;
_onUpdate();
if (options.SolutionFullPath.IsNotEmpty())
{
var projects = projectFinder
.FindInTheSolution(
solutionDirectory: Path.GetDirectoryName(options.SolutionFullPath),
fileName: Path.GetFileName(options.SolutionFullPath))
.ToArray();
_onUpdate();
projectUpdater.Run(
projects,
project =>
{
var task = _taskCreator.Create <ProjectInSolution>();
atLeastOneUpdated |= task.Run(project, (UpdateProjectOptions)options.WithPreview(preview));
_onUpdate();
});
}
else
{
var projects = projectFinder
.FindWithMask(
workingDirectory: options.WorkingDirectory,
options.CsProjFileMasks)
.ToArray();
_onUpdate();
projectUpdater.Run(
projects,
project =>
{
var task = _taskCreator.Create <ProjectInFileSystem>();
atLeastOneUpdated |= task.Run(project, (UpdateProjectOptions)options.WithPreview(preview));
_onUpdate();
});
}
if (!atLeastOneUpdated)
{
Log.Information("\tTask completed. No changes.");
}
return(atLeastOneUpdated);
}
public void sets_the_CurrentFolder()
{
fileSystem.DeleteDirectory("deep1");
fileSystem.CreateDirectory("deep1");
CsProjFile.CreateAtSolutionDirectory("Foo", "deep1").Save();
fileSystem.CreateDirectory("deep1", "Foo", "A");
var location = ProjectFinder.DetermineLocation("deep1".AppendPath("Foo", "A"));
location.CurrentFolder.ToFullPath().ShouldEqual(Environment.CurrentDirectory.ToFullPath().AppendPath("deep1", "Foo", "A"));
}
public void find_shallow()
{
fileSystem.DeleteDirectory("shallow");
fileSystem.CreateDirectory("shallow");
CsProjFile.CreateAtSolutionDirectory("Foo", "shallow").Save();
var location = ProjectFinder.DetermineLocation("shallow".AppendPath("Foo"));
location.Project.AssemblyName.ShouldEqual("Foo");
location.Namespace.ShouldEqual("Foo");
location.RelativePath.ShouldBeEmpty();
}
private string GetProjectFile(string solutionFile, NugetPackageInfo package)
{
var projectFiles = Directory.GetFiles(Path.GetDirectoryName(solutionFile), "*.csproj", SearchOption.AllDirectories);
var isSolutionTiered = IsSolutionTiered(projectFiles);
var projectFile = ProjectFinder.FindNuGetTargetProjectFile(
projectFiles,
isSolutionTiered && package.TieredTarget != NuGetPackageTarget.Undefined
? package.TieredTarget
: package.Target);
return(projectFile);
}
private async Task AddNugetAndNpmReferences(ModuleWithMastersInfo module, string[] projectFiles,
bool useDotnetCliToInstall)
{
var webPackagesWillBeAddedToBlazorServerProject = SouldWebPackagesBeAddedToBlazorServerProject(module, projectFiles);
foreach (var nugetPackage in module.NugetPackages)
{
var nugetTarget =
await IsProjectTiered(projectFiles) && nugetPackage.TieredTarget != NuGetPackageTarget.Undefined
? nugetPackage.TieredTarget
: nugetPackage.Target;
if (webPackagesWillBeAddedToBlazorServerProject && nugetTarget == NuGetPackageTarget.Web)
{
nugetTarget = NuGetPackageTarget.BlazorServer;
}
var targetProjectFile = ProjectFinder.FindNuGetTargetProjectFile(projectFiles, nugetTarget);
if (targetProjectFile == null)
{
Logger.LogDebug($"Target project is not available for this NuGet package '{nugetPackage.Name}'");
continue;
}
await ProjectNugetPackageAdder.AddAsync(null, targetProjectFile, nugetPackage, null, useDotnetCliToInstall);
}
var mvcNpmPackages = module.NpmPackages?.Where(p => p.ApplicationType.HasFlag(NpmApplicationType.Mvc))
.ToList();
if (!mvcNpmPackages.IsNullOrEmpty())
{
var targetProjects = ProjectFinder.FindNpmTargetProjectFile(projectFiles);
if (targetProjects.Any())
{
NpmGlobalPackagesChecker.Check();
foreach (var targetProject in targetProjects)
{
foreach (var npmPackage in mvcNpmPackages)
{
await ProjectNpmPackageAdder.AddMvcPackageAsync(Path.GetDirectoryName(targetProject), npmPackage);
}
}
}
else
{
Logger.LogDebug("Target project is not available for NPM packages.");
}
}
}
public void FindWithProjectFiles()
{
using (var fs = new DisposableFileSystem())
{
fs.CreateFile("project1.csproj")
.CreateFile("project2.csproj");
var finder = new ProjectFinder(fs.RootPath);
var projects = finder.FindProjects().OrderBy(p => p.Name).ToArray();
Assert.Equal("project1.csproj", projects[0].Name);
Assert.Equal("project2.csproj", projects[1].Name);
}
}
public void find_deep_2()
{
fileSystem.DeleteDirectory("deep2");
fileSystem.CreateDirectory("deep2");
CsProjFile.CreateAtSolutionDirectory("Foo", "deep2").Save();
fileSystem.CreateDirectory("deep2", "Foo", "A", "B");
var location = ProjectFinder.DetermineLocation("deep2".AppendPath("Foo", "A", "B"));
location.Project.AssemblyName.ShouldEqual("Foo");
location.Namespace.ShouldEqual("Foo.A.B");
location.RelativePath.ShouldEqual("A\\B");
}
public async Task UpdateSolutionAsync(string solutionPath, bool includePreviews = false, bool includeReleaseCandidates = false, bool switchToStable = false, bool checkAll = false, string version = null)
{
var projectPaths = ProjectFinder.GetProjectFiles(solutionPath);
if (checkAll && version.IsNullOrWhiteSpace())
{
Task.WaitAll(projectPaths.Select(projectPath => UpdateInternalAsync(projectPath, includePreviews, includeReleaseCandidates, switchToStable)).ToArray());
}
else
{
var latestVersionFromNuget = await _nuGetService.GetLatestVersionOrNullAsync("Volo.Abp.Core", includeReleaseCandidates : includeReleaseCandidates);
var latestReleaseCandidateVersionFromNuget = await _nuGetService.GetLatestVersionOrNullAsync("Volo.Abp.Core", includeReleaseCandidates : true);
var latestVersionFromMyGet = await GetLatestVersionFromMyGet("Volo.Abp.Core");
async Task UpdateAsync(string filePath)
{
using (var fs = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
using (var sr = new StreamReader(fs, Encoding.Default, true))
{
var fileContent = await sr.ReadToEndAsync();
var updatedContent = await UpdateVoloPackagesAsync(fileContent,
includePreviews,
includeReleaseCandidates,
switchToStable,
latestVersionFromNuget,
latestReleaseCandidateVersionFromNuget,
latestVersionFromMyGet,
version);
fs.Seek(0, SeekOrigin.Begin);
fs.SetLength(0);
using (var sw = new StreamWriter(fs, DefaultEncoding))
{
await sw.WriteAsync(updatedContent);
await sw.FlushAsync();
}
}
}
}
Task.WaitAll(projectPaths.Select(UpdateAsync).ToArray());
}
}
protected static void PerformUpdateComponents(ProjectFinder projectFinder, BuildDependencyInfo dependencyInfo, OptionValues optionValues)
{
var graph = dependencyInfo.TrimmedSolutionDependencyGraph;
var sortedSolutions = GetDependencySortedSolutionNames(dependencyInfo);
if (optionValues.Build)
{
foreach (var solutionFileName in sortedSolutions.Where(x => graph.OutEdges(x).Any()))
{
Builder.BuildSolution(projectFinder, solutionFileName, optionValues.MatchingAssemblyRegexes, optionValues.FlipIgnore, optionValues.IgnoreMissingAssemblies, optionValues.CleanBeforeBuild, optionValues.RunTests, optionValues.IgnoreFailedTests);
}
}
foreach (var solutionFileName in sortedSolutions.Where(x => false == graph.OutEdges(x).Any()))
{
Builder.UpdateComponentsFromBuiltProjects(projectFinder, solutionFileName, optionValues.MatchingAssemblyRegexes, optionValues.FlipIgnore, optionValues.IgnoreMissingAssemblies);
}
}
public void FindNpmTargetProjectFile_Tests()
{
var npmTargets = ProjectFinder.FindNpmTargetProjectFile(
new[]
{
GetNormalizedPath(@"c:\temp\project\folder\src\Acme.PhoneBook.Host.csproj"),
GetNormalizedPath(@"c:\temp\project\folder\src\Acme.PhoneBook.Web.Host.csproj"),
GetNormalizedPath(@"c:\temp\project\folder\src\Acme.PhoneBook.HttpApi.Host.csproj"),
GetNormalizedPath(@"c:\temp\project\folder\src\Acme.PhoneBook.Application.Contracts.csproj"),
GetNormalizedPath(@"c:\temp\project\folder\src\Acme.PhoneBook.Application.csproj"),
GetNormalizedPath(@"c:\temp\project\folder\src\Acme.PhoneBook.EntityFrameworkCore.csproj")
}
);
npmTargets.ShouldContain(GetNormalizedPath(@"c:\temp\project\folder\src\Acme.PhoneBook.Host.csproj"));
npmTargets.ShouldContain(GetNormalizedPath(@"c:\temp\project\folder\src\Acme.PhoneBook.Web.Host.csproj"));
}
public void FindWithSolutionFile()
{
using (var fs = new DisposableFileSystem())
{
fs.CreateFile("MySolution.sln")
.CreateFolder("src/project")
.CreateFile("src/project/proj1.csproj");
var finder = new ProjectFinder(fs.RootPath);
var projectFiles = finder.FindProjects();
var project = projectFiles.First();
Assert.Single(projectFiles);
Assert.Equal("proj1.csproj", project.Name);
}
}
/// <summary>
/// This function is the callback used to execute the command when the menu item is clicked.
/// See the constructor to see how the menu item is associated with this function using
/// OleMenuCommandService service and MenuCommand class.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
private void Execute(object sender, EventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
var componentModel = ServiceProvider.GetServiceAsync(typeof(SComponentModel)).Result as IComponentModel;
var currentWorkspace = componentModel.GetService <VisualStudioWorkspace>();
var projectFinder = new ProjectFinder(currentWorkspace.CurrentSolution);
var generator = new Generator();
var recorder = new Recorder(projectFinder, generator);
recorder.Save();
string message = "Terminé avec succès";
string title = "Génération";
VsShellUtilities.ShowMessageBox(
this.package,
message,
title,
OLEMSGICON.OLEMSGICON_INFO,
OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
}
public FindUsagesHandler(BufferParser parser, ISolution solution, ProjectFinder projectFinder)
{
_projectFinder = projectFinder;
_parser = parser;
_solution = solution;
}
public virtual async Task <ModuleWithMastersInfo> AddAsync([NotNull] string solutionFile,
[NotNull] string moduleName,
string version,
bool skipDbMigrations = false,
bool withSourceCode = false,
bool addSourceCodeToSolutionFile = false,
bool newTemplate = false,
bool newProTemplate = false)
{
Check.NotNull(solutionFile, nameof(solutionFile));
Check.NotNull(moduleName, nameof(moduleName));
await PublishEventAsync(1, "Retriving module info...");
var module = await GetModuleInfoAsync(moduleName, newTemplate, newProTemplate);
await PublishEventAsync(2, "Removing incompatible packages from module...");
module = RemoveIncompatiblePackages(module, version);
Logger.LogInformation($"Installing module '{module.Name}' to the solution '{Path.GetFileNameWithoutExtension(solutionFile)}'");
var projectFiles = ProjectFinder.GetProjectFiles(solutionFile);
await AddNugetAndNpmReferences(module, projectFiles, !(newTemplate || newProTemplate));
if (withSourceCode || newTemplate || newProTemplate)
{
var modulesFolderInSolution = Path.Combine(Path.GetDirectoryName(solutionFile), "modules");
await PublishEventAsync(5, $"Downloading source code of {moduleName}");
await DownloadSourceCodesToSolutionFolder(module, modulesFolderInSolution, version, newTemplate, newProTemplate);
await PublishEventAsync(6, $"Deleting incompatible projects from the module source code");
await RemoveUnnecessaryProjectsAsync(Path.GetDirectoryName(solutionFile), module, projectFiles);
if (addSourceCodeToSolutionFile)
{
await PublishEventAsync(7, $"Adding module to solution file");
await SolutionFileModifier.AddModuleToSolutionFileAsync(module, solutionFile);
}
await PublishEventAsync(8, $"Changing nuget references to local references");
if (newTemplate || newProTemplate)
{
await NugetPackageToLocalReferenceConverter.Convert(module, solutionFile, $"{module.Name}.");
}
else
{
await NugetPackageToLocalReferenceConverter.Convert(module, solutionFile);
}
await AddAngularSourceCode(modulesFolderInSolution, solutionFile, module.Name, newTemplate || newProTemplate);
}
else
{
await AddAngularPackages(solutionFile, module);
}
await RunBundleForBlazorAsync(projectFiles, module);
await ModifyDbContext(projectFiles, module, skipDbMigrations);
var documentationLink = module.GetFirstDocumentationLinkOrNull();
if (documentationLink != null)
{
CmdHelper.OpenWebPage(documentationLink);
}
return(module);
}
private static void PerformCommands(ISet <string> exlcudedSlns, ISet <string> inputFiles, OptionValues optionValues)
{
var projectFinder = new ProjectFinder(optionValues.BasePath, true);
foreach (var project in projectFinder.AllProjectsInPath())
{
ValidateProject(project, optionValues);
}
if (optionValues.IncludeAllSLNsAsInputs)
{
var slnFiles = projectFinder.AllProjectsInPath()
.Where(projectFinder.ProjectHasMatchingSLNFile)
.Select(projectFinder.GetSLNFileForProject)
.Select(x => x.FullName)
.Distinct();
_logger.Info("Adding SLN inputs:");
foreach (var slnFile in slnFiles.OrderBy(x => x))
{
inputFiles.Add(slnFile);
_logger.Info("\t" + slnFile);
}
}
var dependencyInfo = Soldr.Resolver.BuildDependencyResolver.GetDependencyInfo(projectFinder, inputFiles, exlcudedSlns, optionValues.RecursionLevel); //, optionValues.Dependents);
if (optionValues.GenerateGraphviz)
{
GenerateGraphViz(dependencyInfo.SolutionDependencyGraph);
}
if (optionValues.PrintSolutionBuildOrder)
{
PrintSolutionBuildOrder(dependencyInfo);
}
if (optionValues.PrintProjectBuildOrder)
{
PrintProjectBuildOrder(dependencyInfo);
}
if (optionValues.GenerateMSBuildFiles)
{
GenerateMSBuildFiles(dependencyInfo, false == optionValues.OutputMultipleMSBuildFiles);
}
if (optionValues.GenerateNUSpecFiles)
{
GenerateNUSpecFiles(dependencyInfo, optionValues);
}
if (optionValues.GenerateNugetPackagesConfig)
{
GenerateNugetPackagesConfig(dependencyInfo, optionValues);
}
if (optionValues.UpdateComponents)
{
PerformUpdateComponents(projectFinder, dependencyInfo, optionValues);
Console.Error.WriteLine("Dependencies updated.");
}
else if (optionValues.Build)
{
PerformBuild(projectFinder, dependencyInfo, optionValues);
Console.Error.WriteLine("Build complete.");
}
}
public ProjectFinderTests()
{
_filesystem = new Mock <IFilesystem>(MockBehavior.Strict);
_testee = new ProjectFinder(_filesystem.Object);
}
public PhaseController(ProjectFinder projectFinder, IPhaseDetector phaseDetector)
{
this.projectFinder = projectFinder;
this.phaseDetector = phaseDetector;
}
protected override int Run(BuildEngine engine)
{
string targetName = String.Join(",", _buildTask.Targets);
if (String.IsNullOrEmpty(targetName))
targetName = "(default)";
int errors = 0;
if (_target.TextLog != null)
errors += new LogFileOutput(_target.TextLog.AbsolutePath(_namedValues), _target.TextLog.Level).Perform(engine);
if (_target.XmlLog != null)
errors += new XmlFileOutput(_target.XmlLog.AbsolutePath(_namedValues), _target.XmlLog.Level).Perform(engine);
//Globals must preceed project loading
errors += new SetGlobal(MSProp.Configuration, _target.Configuration).Perform(engine);
errors += new SetGlobal(MSProp.Platform, _target.Platform.ToString()).Perform(engine);
foreach (KeyValuePair<string,string> property in _properties)
engine.Properties.SetValue(property.Key, property.Value);
foreach (BuildProperty prop in _target.BuildProperties)
if (prop.IsGlobal)
engine.Properties.SetValue(prop.Name, Environment.ExpandEnvironmentVariables(prop.Value));
Log.Info("CSBuild {0} {1} - Runtime={2}, Configuration={3}, Platform={4}",
targetName.ToLower(), _target.GroupName.ToLower(), engine.Framework.ToString().Insert(2,"."),
engine.Properties[MSProp.Configuration], engine.Properties[MSProp.Platform]);
//Add projects
ProjectFinder projects = new ProjectFinder(this);
projects.Add(_config.Projects.AddProjects);
projects.Add(_target.AddProjects);
projects.Remove(_config.Projects.RemoveProjects);
projects.Remove(_target.RemoveProjects);
errors += projects.Perform(engine);
if (errors > 0 && !_config.Options.ContinueOnError)
return errors;
//Add #defines
List<string> defines = new List<string>();
foreach (BuildDefineConst define in _target.DefineConstants)
defines.Add(define.Value);
if (defines.Count > 0)
errors += new DefineConstants(defines.ToArray()).Perform(engine);
//Project configuration
foreach (BuildProperty property in _target.BuildProperties)
if(!property.IsGlobal)
errors += new SetProjectProperty(property.Name, Environment.ExpandEnvironmentVariables(property.Value)).Perform(engine);
if (_target.TargetFramework != null)
errors += new SetProjectProperty(MSProp.TargetFrameworkVersion, _target.TargetFramework.Version.ToString().Insert(2, ".")).Perform(engine);
if(_target.OutputPath != null)
errors += new SetProjectPathProperty(MSProp.OutputPath, _target.OutputPath.AbsolutePath(_namedValues)).Perform(engine);
if(_target.IntermediateFiles != null)
errors += new SetProjectPathProperty(MSProp.IntermediateOutputPath, _target.IntermediateFiles.AbsolutePath(_namedValues)).Perform(engine);
errors += new SetSolutionDir().Perform(engine);
errors += new NewerFrameworkReferences().Perform(engine);
EnforceReferences folders = new EnforceReferences(engine.Framework, _namedValues, _config.Options.StrictReferences, _config.Options.NoStdReferences, _config.Options.ForceReferencesToFile);
folders.Add(_config.Projects.ReferenceFolders);
folders.Add(_target.ReferenceFolders);
errors += folders.Perform(engine);
if (errors > 0 && !_config.Options.ContinueOnError)
return errors;
System.Diagnostics.TraceLevel warningLevel;
bool saveChanges = _config.Options.SaveProjectChanges(out warningLevel);
if (_target.SaveProjectChanges != null)
{
saveChanges = _target.SaveProjectChanges.Enabled;
warningLevel = _target.SaveProjectChanges.LogLevel;
}
if(saveChanges)
errors += new SaveModifiedProjects(warningLevel).Perform(engine);
//Build it
errors += _buildTask.Perform(engine);
return errors;
}
public GotoImplementationHandler(ISolution solution, BufferParser bufferParser, ProjectFinder projectFinder)
{
_solution = solution;
_bufferParser = bufferParser;
_projectFinder = projectFinder;
}
public Recorder(ProjectFinder projectFinder, Generator generator)
{
this.projectFinder = projectFinder;
this.generator = generator;
}
