public static int CreateDisposableTestProject(string runtimeHomeDir, string targetDir, string projectDir) { // Find the misc project to copy var targetProjectDir = Path.Combine(targetDir, Path.GetFileName(projectDir)); CopyFolder(projectDir, targetProjectDir); // Make sure package restore can be successful var currentDnxSolutionRootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory()); File.Copy(Path.Combine(currentDnxSolutionRootDir, NuGet.Constants.SettingsFileName), Path.Combine(targetProjectDir, NuGet.Constants.SettingsFileName)); // Use the newly built runtime to generate lock files for samples string stdOut, stdErr; return(DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "restore", arguments: targetProjectDir, stdOut: out stdOut, stdErr: out stdErr)); }
private void WriteGlobalJson() { var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory); var rootObject = default(JObject); if (GlobalSettings.HasGlobalFile(rootDirectory)) { rootObject = JObject.Parse(File.ReadAllText(Path.Combine( rootDirectory, GlobalSettings.GlobalFileName))); } else { rootObject = new JObject(); } var applicationRoot = Path.Combine(OutputPath, PublishRoot.AppRootName); // All dependency projects go to approot/src folder // so we remove all other useless entries that might bring in ambiguity rootObject["projects"] = new JArray(SourceFolderName); rootObject["packages"] = PathUtility.GetRelativePath( PathUtility.EnsureTrailingForwardSlash(applicationRoot), TargetPackagesPath, separator: '/'); File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName), rootObject.ToString()); }
public static void Publish( string root, PublishOptions publishOptions, ProjectPackSubSystem.PackOptions packOptions) { string src = Path.Combine(root, "build", "module.json"); ProjectPackSubSystem.Pack(root, packOptions); if (!File.Exists(src)) { EventManager <ErrorEvent> .SendEvent(new FileNotFoundEvent( src, false )); return; } ProjectConfig t = ProjectConfig.Load(src); Logger.LogMessage(LoggerSystems.ModuleSystem, "Publishing '{0}'", src); ProjectResolver.GetManager(publishOptions.Repository). AddPackage( t, Path.Combine(root, "build", "module.zip") ); }
private static void HasNotChanged(Type type) { var projectResolver = new ProjectResolver(); var typeLoader = new ReflectionTypeLoader(); var projectInfo = projectResolver.GetProjectInfo(type); var api = typeLoader.LoadApi(type); Directory.CreateDirectory(projectInfo.TestFolderPath); if (!projectResolver.ApiFileExists(projectInfo, type)) { projectResolver.WriteApiToFile(projectInfo, type, api); return; } var existingApi = projectResolver.ReadApiFromFile(projectInfo, type); var compareStrategy = new BestGuessEndpointMatchingStrategy(); var comparer = new ApiComparer(compareStrategy); comparer.Compare(existingApi, api); // Nice to have: // Fields / Events / Delegates // Supporting constructor arguments on attributes // Multiple public types per file // custom struct as type // Re-generate the output file if there are changes to the API that aren't breaking }
public void BuildPackageAndCheckServiceability(string projectName, bool expectedServiceability) { var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory()); var projectSrcDir = Path.Combine(rootDir, "misc", "ServicingTestProjects", projectName); const string configuration = "Debug"; var components = TestUtils.GetRuntimeComponentsCombinations().First(); var flavor = (string)components[0]; var os = (string)components[1]; var architecture = (string)components[2]; using (var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture)) using (var tempDir = new DisposableDir()) { var projectDir = Path.Combine(tempDir, projectName); var buildOutpuDir = Path.Combine(tempDir, "output"); TestUtils.CopyFolder(projectSrcDir, projectDir); var exitCode = DnuTestUtils.ExecDnu(runtimeHomeDir, "restore", projectDir); Assert.Equal(0, exitCode); exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, "pack", $"{projectDir} --out {buildOutpuDir} --configuration {configuration}"); Assert.Equal(0, exitCode); var assemblyPath = Path.Combine(buildOutpuDir, configuration, "dnx451", $"{projectName}.dll"); Assert.Equal(expectedServiceability, LockFileUtils.IsAssemblyServiceable(assemblyPath)); } }
public override void Run(IEnumerable <string> args) { ArgumentSyntaxParser.Parse(args.Skip(1).ToArray(), this); TcpProjectDatabaseServer server = new TcpProjectDatabaseServer( ProjectResolver.GetManager(args.First()), Port, Path.Combine( AppRootHelper.AppRoot, "cache/upload_server" ) ); Thread t = new Thread(server.ServerLoop); t.Start(); while (true) { System.Console.WriteLine("'exit' to close server"); System.Console.Write(">"); string text = System.Console.ReadLine(); if (text.ToLower() == "exit") { break; } } server.Stop(); }
private DefaultRazorProjectService CreateProjectService( ProjectResolver projectResolver, ProjectSnapshotManagerBase projectSnapshotManager, DocumentResolver documentResolver = null, DocumentVersionCache documentVersionCache = null) { documentVersionCache = documentVersionCache ?? Mock.Of <DocumentVersionCache>(); var filePathNormalizer = new FilePathNormalizer(); var accessor = Mock.Of <ProjectSnapshotManagerAccessor>(a => a.Instance == projectSnapshotManager); documentResolver = documentResolver ?? Mock.Of <DocumentResolver>(); var hostDocumentFactory = new TestHostDocumentFactory(); var remoteTextLoaderFactory = Mock.Of <RemoteTextLoaderFactory>(factory => factory.Create(It.IsAny <string>()) == Mock.Of <TextLoader>()); var projectService = new DefaultRazorProjectService( Dispatcher, hostDocumentFactory, remoteTextLoaderFactory, documentResolver, projectResolver, documentVersionCache, filePathNormalizer, accessor, LoggerFactory); return(projectService); }
public void ResolveNewNamedResxResources() { var expected = new[] { "testproject.OwnResources.resources", "testproject.subfolder.nestedresource.resources", "thisIs.New.Resource.resources" }; var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory()); var testProjectFolder = Path.Combine(rootDir, "misc", "ResourcesTestProjects", "testproject"); Project project = ProjectUtilities.GetProject(@" { ""namedResource"": { ""thisIs.New.Resource"": ""../someresources/OtherResources.resx"" } }", "testproject", Path.Combine(testProjectFolder, "project.json")); var resolver = new ResxResourceProvider(); var embeddedResources = resolver.GetResources(project).Select(resource => resource.Name).ToArray(); Assert.Equal(expected, embeddedResources); }
public Project(Stream stream, ProjectResolver resolver) { _services = new ServiceContainer(); _levels = new NamedResourceCollection <Level>(); _levels.Modified += (s, e) => OnModified(EventArgs.Empty); _libraryManager = new LibraryManager(); _libraryManager.Libraries.Modified += (s, e) => OnModified(EventArgs.Empty); Extra = new List <XmlElement>(); XmlReaderSettings settings = new XmlReaderSettings() { CloseInput = true, IgnoreComments = true, IgnoreWhitespace = true, }; using (XmlReader reader = XmlTextReader.Create(stream, settings)) { XmlSerializer serializer = new XmlSerializer(typeof(ProjectX)); ProjectX proxy = serializer.Deserialize(reader) as ProjectX; FromXProxy(proxy, resolver, this); } ResetModified(); }
private bool WrapAssembly() { if (string.IsNullOrEmpty(Framework)) { Reports.Error.WriteLine("Please specify framework when wrapping an assembly", Framework.Red().Bold()); return(false); } var frameworkName = VersionUtility.ParseFrameworkName(Framework); if (VersionUtility.UnsupportedFrameworkName.Equals(frameworkName)) { Reports.Error.WriteLine("The framework '{0}' is not supported", Framework.Red().Bold()); return(false); } var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory()); var wrapRoot = Path.Combine(rootDir, WrapRootName); EmitAssemblyWrapper(wrapRoot, frameworkName, InputFilePath); AddWrapFolderToGlobalJson(rootDir); return(true); }
public Project(Stream stream, ProjectResolver resolver) { _services = new ServiceContainer(); _levels = new NamedResourceCollection<Level>(); _levels.Modified += (s, e) => OnModified(EventArgs.Empty); _libraryManager = new LibraryManager(); _libraryManager.Libraries.Modified += (s, e) => OnModified(EventArgs.Empty); Extra = new List<XmlElement>(); XmlReaderSettings settings = new XmlReaderSettings() { CloseInput = true, IgnoreComments = true, IgnoreWhitespace = true, }; using (XmlReader reader = XmlTextReader.Create(stream, settings)) { XmlSerializer serializer = new XmlSerializer(typeof(ProjectX)); ProjectX proxy = serializer.Deserialize(reader) as ProjectX; FromXProxy(proxy, resolver, this); } ResetModified(); }
private void WriteGlobalJson() { var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory); var rootObject = default(JObject); if (GlobalSettings.HasGlobalFile(rootDirectory)) { rootObject = JObject.Parse(File.ReadAllText(Path.Combine( rootDirectory, GlobalSettings.GlobalFileName))); } else { rootObject = new JObject(); } var applicationRoot = Path.Combine(OutputPath, PublishRoot.AppRootName); rootObject["packages"] = PathUtility.GetRelativePath( PathUtility.EnsureTrailingForwardSlash(applicationRoot), TargetPackagesPath, separator: '/'); File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName), rootObject.ToString()); }
public void Save(Stream stream, ProjectResolver resolver) { if (_project != null) { _project.Save(stream, resolver); Modified = false; } }
public static void Restore(string projectRoot, string repo) { string src = Path.Combine(projectRoot, "project.json"); ProjectConfig t = ProjectConfig.Load(src); ProjectResolver.GetManager(repo).Restore(t, projectRoot); }
public static Project FromXProxy(ProjectX proxy, ProjectResolver resolver) { if (proxy == null) { return(null); } return(FromXProxy(proxy, resolver, new Project())); }
public static DisposableDir GetTempTestSolution(string name) { var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory()); var sourceSolutionPath = Path.Combine(rootDir, "misc", "KpmWrapTestSolutions", name); var targetSolutionPath = CreateTempDir(); CopyFolder(sourceSolutionPath, targetSolutionPath); return(targetSolutionPath); }
public override void Restore(ProjectConfig target, string rootDir) { foreach (ProjectDependency targetDependency in target.Dependencies) { Get( ProjectResolver.Resolve(this, targetDependency), Path.Combine(rootDir, targetDependency.ProjectName) ); } }
public static Project FromXProxy(ProjectX proxy, ProjectResolver resolver, Project project) { if (proxy == null) { return(null); } if (proxy.PropertyGroup != null) { project.Uid = proxy.PropertyGroup.ProjectGuid; project.Name = proxy.PropertyGroup.ProjectName; project._defaultLibraryUid = proxy.PropertyGroup.DefaultLibrary; project.Extra = new List <XmlElement>(proxy.PropertyGroup.Extra ?? new XmlElement[0]); } project._texturePool = new MetaTexturePool(); project._tilePools = new MetaTilePoolManager(project._texturePool); project._objectPools = new MetaObjectPoolManager(project._texturePool); project._tileBrushes = new MetaTileBrushManager(); foreach (var itemGroup in proxy.ItemGroups) { if (itemGroup.Libraries != null) { foreach (var libProxy in itemGroup.Libraries) { using (Stream stream = resolver.InputStream(libProxy.Include)) { project.AddLibrary(new Library(stream) { FileName = libProxy.Include, }); } } } if (itemGroup.Levels != null) { foreach (var level in itemGroup.Levels) { using (Stream stream = resolver.InputStream(level.Include)) { project.Levels.Add(new Level(stream, project) { FileName = level.Include, }); } } } } //project._tilePools.Pools.PropertyChanged += project.TilePoolsModifiedHandler; //project._objectPools.Pools.PropertyChanged += project.HandleObjectPoolManagerPropertyChanged; return(project); }
public void InversionOfControlContainerMustResolveProjectResolver() { IServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddDbContext <PortfolioApplicationDbContext>(o => o.UseInMemoryDatabase(Guid.NewGuid().ToString())); IContainer container = serviceCollection.AddApplicationModules(); ProjectResolver resolvedComponent = container.Resolve <ProjectResolver>(); Assert.IsType <ProjectResolver>(resolvedComponent); }
public override void RunJob( string projectRoot, ProjectConfig project, ProjectBuildTarget target, ProjectBuildJob job) { foreach (KeyValuePair <string, string> keyValuePair in job.Arguments) { ProjectConfig info = ProjectResolver.Resolve(keyValuePair.Key, keyValuePair.Value); info.Manager.Get(info, Path.Combine(projectRoot, info.ProjectName)); } }
public void CanRoundtripDeserializeApi() { var resolver = new ProjectResolver(); var typeLoader = new ReflectionTypeLoader(); var api = typeLoader.LoadApi(typeof(TestApi)); var serializedApi = resolver.SerializeApi(api); var deserializedApi = resolver.DeserializeApi(serializedApi); Assert.Equal(api, deserializedApi); api.NestedElements.ForEach(x => Assert.NotNull(x.Parent)); deserializedApi.NestedElements.ForEach(x => Assert.NotNull(x.Parent)); }
public void WatchProject(string projectPath) { if (string.IsNullOrEmpty(projectPath)) { return; } // If any watchers already handle this path then noop if (!IsAlreadyWatched(projectPath)) { // To reduce the number of watchers we have we add a watcher to the root // of this project so that we'll be notified if anything we care // about changes var rootPath = ProjectResolver.ResolveRootDirectory(projectPath); AddWatcher(rootPath); } }
public void ResolveEmbeddedResources() { var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory()); var testProjectFolder = Path.Combine(rootDir, "misc", "ResourcesTestProjects", "testproject"); Project project; bool projectFound = Project.TryGetProject(testProjectFolder, out project); Assert.True(projectFound); var resolver = new EmbeddedResourceProvider(); var embeddedResource = resolver.GetResources(project); Assert.Equal("testproject.owntext.txt", embeddedResource[0].Name); Assert.Equal("testproject.subfolder.nestedtext.txt", embeddedResource[1].Name); Assert.Equal("testproject.OtherText.txt", embeddedResource[2].Name); }
public bool ExecuteCommand() { var sw = new Stopwatch(); sw.Start(); var restoreDirectory = RestoreDirectory ?? Directory.GetCurrentDirectory(); var projectJsonFiles = Directory.GetFiles(restoreDirectory, "project.json", SearchOption.AllDirectories); var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory); ReadSettings(rootDirectory); string packagesDirectory = PackageFolder; if (string.IsNullOrEmpty(PackageFolder)) { packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory); } var packagesFolderFileSystem = CreateFileSystem(packagesDirectory); var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true); var localRepository = new LocalPackageRepository(pathResolver, packagesFolderFileSystem); int restoreCount = 0; int successCount = 0; foreach (var projectJsonPath in projectJsonFiles) { restoreCount += 1; var success = RestoreForProject(localRepository, projectJsonPath, rootDirectory, packagesDirectory).Result; if (success) { successCount += 1; } } if (restoreCount > 1) { Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds)); } return(restoreCount == successCount); }
private static void WriteLevel(ProjectResolver resolver, Level level, string levelPath) { using (Stream stream = resolver.OutputStream(levelPath)) { XmlWriterSettings settings = new XmlWriterSettings() { CloseOutput = true, Indent = true, }; XmlWriter writer = XmlTextWriter.Create(stream, settings); LevelX proxy = Level.ToXProxy(level); XmlSerializer serializer = new XmlSerializer(typeof(LevelX)); serializer.Serialize(writer, proxy); writer.Close(); } }
private static string ResolvePackagesDirectory(string projectDir) { var rootDir = ProjectResolver.ResolveRootDirectory(projectDir); var settings = SettingsUtils.ReadSettings( solutionDir: rootDir, nugetConfigFile: null, fileSystem: new PhysicalFileSystem(projectDir), machineWideSettings: new CommandLineMachineWideSettings()); var packagesDir = settings.GetRepositoryPath(); // If 'repositoryPath' is not specified in NuGet.config, use {SolutionRoot}/packages as default if (string.IsNullOrEmpty(packagesDir)) { packagesDir = Path.Combine(rootDir, "packages"); } return(Path.GetFullPath(packagesDir)); }
public void ProjectResolverThrowsWhenResolvingAmbiguousName() { const string ambiguousName = "ProjectA"; var solutionStructure = @"{ 'global.json': '', 'src1': { 'ProjectA': { 'project.json': '{}' } }, 'src2': { 'ProjectA': { 'project.json': '{}' } } }"; using (var solutionPath = new DisposableDir()) { DirTree.CreateFromJson(solutionStructure) .WithFileContents("global.json", @"{ ""projects"": [""src1"", ""src2""] }") .WriteTo(solutionPath); var src1ProjectPath = Path.Combine(solutionPath, "src1", ambiguousName); var src2ProjectPath = Path.Combine(solutionPath, "src2", ambiguousName); var expectedMessage = $@"The project name '{ambiguousName}' is ambiguous between the following projects: {src1ProjectPath} {src2ProjectPath}"; Runtime.Project project = null; var resolver1 = new ProjectResolver(src1ProjectPath); var exception = Assert.Throws <InvalidOperationException>(() => resolver1.TryResolveProject(ambiguousName, out project)); Assert.Contains(expectedMessage, exception.Message); Assert.Null(project); var resolver2 = new ProjectResolver(src2ProjectPath); exception = Assert.Throws <InvalidOperationException>(() => resolver2.TryResolveProject(ambiguousName, out project)); Assert.Contains(expectedMessage, exception.Message); Assert.Null(project); } }
public void ProjectResolverThrowsWhenResolvingAmbiguousName() { const string ambiguousName = "ProjectA"; var solutionStructure = @"{ 'global.json': '', 'src1': { 'ProjectA': { 'project.json': '{}' } }, 'src2': { 'ProjectA': { 'project.json': '{}' } } }"; using (var solutionPath = new DisposableDir()) { DirTree.CreateFromJson(solutionStructure) .WithFileContents("global.json", @"{ ""projects"": [""src1"", ""src2""] }") .WriteTo(solutionPath); var src1ProjectPath = Path.Combine(solutionPath, "src1", ambiguousName); var src2ProjectPath = Path.Combine(solutionPath, "src2", ambiguousName); var expectedMessage = $@"The project name '{ambiguousName}' is ambiguous between the following projects: {src1ProjectPath} {src2ProjectPath}"; Runtime.Project project = null; var resolver1 = new ProjectResolver(src1ProjectPath); var exception = Assert.Throws<InvalidOperationException>(() => resolver1.TryResolveProject(ambiguousName, out project)); Assert.Contains(expectedMessage, exception.Message); Assert.Null(project); var resolver2 = new ProjectResolver(src2ProjectPath); exception = Assert.Throws<InvalidOperationException>(() => resolver2.TryResolveProject(ambiguousName, out project)); Assert.Contains(expectedMessage, exception.Message); Assert.Null(project); } }
public override void Get(ProjectConfig target, string targetDir) { if (Directory.Exists(targetDir)) { Directory.Delete(targetDir, true); } string dataPath = GetTargetDataUri(target); ZipFile.ExtractToDirectory(dataPath, targetDir); foreach (ProjectDependency targetDependency in target.Dependencies) { Get( ProjectResolver.Resolve(this, targetDependency), Path.Combine(targetDir, targetDependency.ProjectName) ); } }
public ModuleLoaderContext(IServiceProvider serviceProvider, string projectDirectory) { ProjectDirectory = projectDirectory; RootDirectory = Microsoft.Dnx.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory); // A new project resolver is required. you cannot reuse the one from the // parent service provider as that will be for the parent context. ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory); var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver()); // Need to pass through package directory incase you download a package from the gallary, this needs to know about it var nuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository( NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory))); var gacDependencyResolver = new GacDependencyResolver(); var projectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver); var unresolvedDependencyProvider = new UnresolvedDependencyProvider(); var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileFormat.LockFileName); if (File.Exists(projectLockJsonPath)) { var lockFileFormat = new LockFileFormat(); var lockFile = lockFileFormat.Read(projectLockJsonPath); nuGetDependencyProvider.ApplyLockFile(lockFile); } DependencyWalker = new DependencyWalker(new IDependencyProvider[] { projectDepencyProvider, nuGetDependencyProvider, referenceAssemblyDependencyResolver, gacDependencyResolver, unresolvedDependencyProvider }); LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] { new ModuleProjectLibraryExportProvider( ProjectResolver, serviceProvider), referenceAssemblyDependencyResolver, gacDependencyResolver, nuGetDependencyProvider }); }
public void BuildPackageAndCheckServiceability(string projectName, bool expectedServiceability) { var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory()); var projectDir = Path.Combine(rootDir, "misc", "ServicingTestProjects", projectName); const string configuration = "Debug"; using (var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor: "clr", os: "win", architecture: "x86")) using (var tempDir = new DisposableDir()) { var buildOutpuDir = Path.Combine(tempDir, "output"); DnuTestUtils.ExecDnu( runtimeHomeDir, "pack", $"{projectDir} --out {buildOutpuDir} --configuration {configuration}"); var assemblyPath = Path.Combine(buildOutpuDir, configuration, "dnx451", $"{projectName}.dll"); Assert.Equal(expectedServiceability, LockFileUtils.IsAssemblyServiceable(assemblyPath)); } }
public static DisposableDir PrepareTemporarySamplesFolder(string runtimeHomeDir) { var tempDir = new DisposableDir(); TestUtils.CopyFolder(TestUtils.GetSamplesFolder(), tempDir); // Make sure sample projects depend on runtime components from newly built dnx var currentDnxSolutionRootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory()); var currentDnxSolutionSrcPath = Path.Combine(currentDnxSolutionRootDir, "src").Replace("\\", "\\\\"); var samplesGlobalJson = new JObject(); samplesGlobalJson["projects"] = new JArray(new[] { currentDnxSolutionSrcPath }); File.WriteAllText(Path.Combine(tempDir, GlobalSettings.GlobalFileName), samplesGlobalJson.ToString()); // Make sure package restore can be successful const string nugetConfigName = "NuGet.Config"; File.Copy(Path.Combine(currentDnxSolutionRootDir, nugetConfigName), Path.Combine(tempDir, nugetConfigName)); // Use the newly built runtime to generate lock files for samples string stdOut, stdErr; int exitCode; foreach (var projectDir in Directory.EnumerateDirectories(tempDir)) { exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "restore", arguments: projectDir, stdOut: out stdOut, stdErr: out stdErr); if (exitCode != 0) { Console.WriteLine(stdOut); Console.WriteLine(stdErr); } } return(tempDir); }
public override void Run(IEnumerable <string> args) { string[] a = args.ToArray(); ArgumentSyntaxParser.Parse(a, Logger.s_Settings); ProjectResolver.Initialize(); CommonFiles.GenerateCommonFiles(); string root = a.Length != 0 ? Path.GetFullPath(a[0]) : Directory.GetCurrentDirectory(); string src = Path.Combine(root, "project.json"); Logger.LogMessage(LoggerSystems.Console, "File: {0}", src); ProjectConfig.AddRunner(new BuildJobBuild()); ProjectConfig.AddRunner(new BuildJobClean()); ProjectConfig.AddRunner(new BuildJobPublish()); ProjectConfig.AddRunner(new BuildJobRestore()); ProjectConfig.AddRunner(new BuildJobExternalBuild()); ProjectConfig.AddRunner(new BuildJobCombinedJobs()); ProjectConfig.AddRunner(new BuildJobMoveContent()); ProjectConfig.AddRunner(new BuildJobCopyContent()); ProjectConfig.AddRunner(new BuildJobRunJob()); ProjectConfig.AddRunner(new BuildJobGetDependency()); ProjectConfig.AddRunner(new BuildJobAddOrigin()); ProjectConfig.AddRunner(new BuildJobRemoveOrigin()); ProjectConfig.AddRunner(new BuildJobMergedJobs()); ProjectConfig.AddRunner(new BuildJobMakeHeader()); ProjectConfig config = ProjectConfig.Load(src); string target = config.DefaultTarget; if (a.Length > 1) { target = a[1]; } config.RunTarget(root, target); }
public static void Initialize(ApplicationHostContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } context.ProjectDirectory = context.Project?.ProjectDirectory ?? context.ProjectDirectory; context.RootDirectory = context.RootDirectory ?? ProjectResolver.ResolveRootDirectory(context.ProjectDirectory); var projectResolver = new ProjectResolver(context.ProjectDirectory, context.RootDirectory); var frameworkReferenceResolver = context.FrameworkResolver ?? new FrameworkReferenceResolver(); context.PackagesDirectory = context.PackagesDirectory ?? PackageDependencyProvider.ResolveRepositoryPath(context.RootDirectory); var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(frameworkReferenceResolver); var gacDependencyResolver = new GacDependencyResolver(); var projectDependencyProvider = new ProjectReferenceDependencyProvider(projectResolver); var unresolvedDependencyProvider = new UnresolvedDependencyProvider(); IList<IDependencyProvider> dependencyProviders = null; LockFileLookup lockFileLookup = null; if (context.Project == null) { Project project; if (Project.TryGetProject(context.ProjectDirectory, out project)) { context.Project = project; } else { throw new InvalidOperationException($"Unable to resolve project from {context.ProjectDirectory}"); } } var projectLockJsonPath = Path.Combine(context.ProjectDirectory, LockFileReader.LockFileName); var lockFileExists = File.Exists(projectLockJsonPath); var validLockFile = false; var skipLockFileValidation = context.SkipLockfileValidation; string lockFileValidationMessage = null; if (lockFileExists) { var lockFileReader = new LockFileReader(); var lockFile = lockFileReader.Read(projectLockJsonPath); validLockFile = lockFile.IsValidForProject(context.Project, out lockFileValidationMessage); // When the only invalid part of a lock file is version number, // we shouldn't skip lock file validation because we want to leave all dependencies unresolved, so that // VS can be aware of this version mismatch error and automatically do restore skipLockFileValidation = context.SkipLockfileValidation && (lockFile.Version == Constants.LockFileVersion); if (validLockFile || skipLockFileValidation) { lockFileLookup = new LockFileLookup(lockFile); var packageDependencyProvider = new PackageDependencyProvider(context.PackagesDirectory, lockFileLookup); dependencyProviders = new IDependencyProvider[] { projectDependencyProvider, packageDependencyProvider, referenceAssemblyDependencyResolver, gacDependencyResolver, unresolvedDependencyProvider }; } } if ((!validLockFile && !skipLockFileValidation) || !lockFileExists) { // We don't add the PackageDependencyProvider to DependencyWalker // It will leave all NuGet packages unresolved and give error message asking users to run "dnu restore" dependencyProviders = new IDependencyProvider[] { projectDependencyProvider, referenceAssemblyDependencyResolver, gacDependencyResolver, unresolvedDependencyProvider }; } var libraries = DependencyWalker.Walk(dependencyProviders, context.Project.Name, context.Project.Version, context.TargetFramework); context.LibraryManager = new LibraryManager(context.Project.ProjectFilePath, context.TargetFramework, libraries); if (!validLockFile) { context.LibraryManager.AddGlobalDiagnostics(new DiagnosticMessage( $"{lockFileValidationMessage}. Please run \"dnu restore\" to generate a new lock file.", Path.Combine(context.Project.ProjectDirectory, LockFileReader.LockFileName), DiagnosticMessageSeverity.Error)); } if (!lockFileExists) { context.LibraryManager.AddGlobalDiagnostics(new DiagnosticMessage( $"The expected lock file doesn't exist. Please run \"dnu restore\" to generate a new lock file.", Path.Combine(context.Project.ProjectDirectory, LockFileReader.LockFileName), DiagnosticMessageSeverity.Error)); } // Clear all the temporary memory aggressively here if we don't care about reuse // e.g. runtime scenarios lockFileLookup?.Clear(); projectResolver.Clear(); }
public void Save(Stream stream, ProjectResolver resolver) { List<ProjectX.LibraryX> libraries = new List<ProjectX.LibraryX>(); List<ProjectX.LevelX> levels = new List<ProjectX.LevelX>(); foreach (Library library in _libraryManager.Libraries) { if (library.FileName == null) library.FileName = FormatSafeFileName(library.Name + ".tlbx"); using (Stream libStream = resolver.OutputStream(library.FileName)) { library.Save(libStream); } libraries.Add(new ProjectX.LibraryX() { Include = library.FileName, }); } foreach (Level level in Levels) { if (level.FileName == null) level.FileName = FormatSafeFileName(level.Name + ".tlvx"); using (Stream levStream = resolver.OutputStream(level.FileName)) { level.Save(levStream); } levels.Add(new ProjectX.LevelX() { Include = level.FileName, }); } XmlWriterSettings settings = new XmlWriterSettings() { CloseOutput = true, Indent = true, }; XmlWriter writer = XmlTextWriter.Create(stream, settings); ProjectX proxy = new ProjectX() { ItemGroups = new List<ProjectX.ItemGroupX>(), PropertyGroup = new ProjectX.PropertyGroupX() { ProjectGuid = Uid, ProjectName = Name, DefaultLibrary = _defaultLibraryUid, Extra = (Extra != null && Extra.Count > 0) ? Extra.ToArray() : null, }, }; proxy.ItemGroups.Add(new ProjectX.ItemGroupX() { Libraries = libraries, }); proxy.ItemGroups.Add(new ProjectX.ItemGroupX() { Levels = levels, }); XmlSerializer serializer = new XmlSerializer(typeof(ProjectX)); serializer.Serialize(writer, proxy); writer.Close(); ResetModified(); }
public static Project FromXProxy(ProjectX proxy, ProjectResolver resolver, Project project) { if (proxy == null) return null; if (proxy.PropertyGroup != null) { project.Uid = proxy.PropertyGroup.ProjectGuid; project.Name = proxy.PropertyGroup.ProjectName; project._defaultLibraryUid = proxy.PropertyGroup.DefaultLibrary; project.Extra = new List<XmlElement>(proxy.PropertyGroup.Extra ?? new XmlElement[0]); } project._texturePool = new MetaTexturePool(); project._tilePools = new MetaTilePoolManager(project._texturePool); project._objectPools = new MetaObjectPoolManager(project._texturePool); project._tileBrushes = new MetaTileBrushManager(); foreach (var itemGroup in proxy.ItemGroups) { if (itemGroup.Libraries != null) { foreach (var libProxy in itemGroup.Libraries) { using (Stream stream = resolver.InputStream(libProxy.Include)) { project.AddLibrary(new Library(stream) { FileName = libProxy.Include, }); } } } if (itemGroup.Levels != null) { foreach (var level in itemGroup.Levels) { using (Stream stream = resolver.InputStream(level.Include)) { project.Levels.Add(new Level(stream, project) { FileName = level.Include, }); } } } } //project._tilePools.Pools.PropertyChanged += project.TilePoolsModifiedHandler; //project._objectPools.Pools.PropertyChanged += project.HandleObjectPoolManagerPropertyChanged; return project; }
private void EmitProjectWrapper(XElement projectElement) { var projectFile = Path.GetFullPath(projectElement.Attribute("projectFile").Value); // Name of the wrapper project is output assembly name, instead of .csproj file name var outputAssemblyPath = GetOutputAssemblyPath(projectElement); outputAssemblyPath = GetConfigAgnosticAssemblyPath(outputAssemblyPath); var projectName = Path.GetFileNameWithoutExtension(outputAssemblyPath); var projectDir = Path.GetDirectoryName(projectFile); var rootDir = ResolveRootDirectory(projectDir); var wrapRoot = Path.Combine(rootDir, WrapRootName); string targetProjectJson; if (InPlace) { targetProjectJson = Path.Combine(projectDir, Runtime.Project.ProjectFileName); } else { var projectResolver = new ProjectResolver(projectDir, rootDir); targetProjectJson = LocateExistingProject(projectResolver, projectName); if (string.IsNullOrEmpty(targetProjectJson)) { AddWrapFolderToGlobalJson(rootDir); targetProjectJson = Path.Combine(wrapRoot, projectName, Runtime.Project.ProjectFileName); } } var targetFramework = GetTargetFramework(projectElement); Reports.Information.WriteLine("Wrapping project '{0}' for '{1}'", projectName, targetFramework); Reports.Information.WriteLine(" Source {0}", projectFile.Bold()); Reports.Information.WriteLine(" Target {0}", targetProjectJson.Bold()); var projectJson = LoadOrCreateProjectJson(targetProjectJson); var relativeCsProjectPath = PathUtility.GetRelativePath(targetProjectJson, projectFile, PathSeparator); AddWrappedProjectPath(projectJson, relativeCsProjectPath, targetFramework); // Add 'assembly' and 'pdb' to 'bin' section of the target framework var relativeAssemblyPath = PathUtility.GetRelativePath(targetProjectJson, outputAssemblyPath, PathSeparator); var relativePdbPath = Path.ChangeExtension(relativeAssemblyPath, ".pdb"); Reports.Information.WriteLine(" Adding bin paths for '{0}'", targetFramework); Reports.Information.WriteLine(" Assembly: {0}", relativeAssemblyPath.Bold()); Reports.Information.WriteLine(" Pdb: {0}", relativePdbPath.Bold()); AddFrameworkBinPaths(projectJson, targetFramework, relativeAssemblyPath, relativePdbPath); var nugetPackages = ResolveNuGetPackages(projectDir); var nugetPackagePaths = nugetPackages.Select(x => x.Path); // Add nuget dependency to 'dependencies' section of the target framework foreach (var package in nugetPackages) { Reports.Information.WriteLine(" Adding package dependency '{0}.{1}'", package.Identity, package.Version); AddNuGetDependency(projectJson, package, targetFramework); } // Add dependency projects to 'dependencies' section of the target framework foreach (var itemElement in GetItemsByType(projectElement, type: "ProjectReference")) { var referenceProjectName = GetMetadataValue(itemElement, "Name"); var outputName = GetReferenceProjectOutputName(projectElement, referenceProjectName); Reports.Information.WriteLine(" Adding project dependency '{0}.{1}'", outputName, WrapperProjectVersion); AddProjectDependency(projectJson, outputName, targetFramework); } // Create wrapper projects for assembly references // and add wrapper projects as project references foreach (var itemElement in GetItemsByType(projectElement, type: "ReferencePath")) { if (IsAssemblyFromProjectReference(itemElement) || IsFrameworkAssembly(itemElement) || IsAssemblyFromNuGetPackage(itemElement, nugetPackagePaths)) { continue; } // This assembly becomes a project reference var assemblyPath = itemElement.Attribute("evaluated").Value; var assemblyProjectName = Path.GetFileNameWithoutExtension(assemblyPath); EmitAssemblyWrapper(wrapRoot, targetFramework, assemblyPath, isSubProcedure: true); Reports.Information.WriteLine(" Adding project dependency '{0}.{1}'", assemblyProjectName, WrapperProjectVersion); AddProjectDependency(projectJson, assemblyProjectName, targetFramework); AddWrapFolderToGlobalJson(rootDir); } PathUtility.EnsureParentDirectory(targetProjectJson); File.WriteAllText(targetProjectJson, projectJson.ToString()); AddToGlobalJsonSources(rootDir, Path.GetDirectoryName(targetProjectJson)); Reports.Information.WriteLine(); }
public static Project FromXProxy(ProjectX proxy, ProjectResolver resolver) { if (proxy == null) return null; return FromXProxy(proxy, resolver, new Project()); }