public UpdatedNuGetPackagesInProject (
			IDotNetProject project,
			IEnumerable<PackageIdentity> packages)
		{
			Project = project;
			this.packages = packages.ToList ();
		}
		public ProjectPackagesFolderNode (
			IDotNetProject project,
			IUpdatedPackagesInSolution updatedPackagesInSolution)
		{
			this.project = project;
			this.updatedPackagesInSolution = updatedPackagesInSolution;
		}
		public PackageCompatibilityRunner (IDotNetProject project)
			: this (
				project,
				PackageManagementServices.ProgressMonitorFactory,
				PackageManagementServices.PackageManagementEvents)
		{
		}
		protected virtual void OnProjectTargetFrameworkChanged (IDotNetProject project)
		{
			var handler = ProjectTargetFrameworkChanged;
			if (handler != null) {
				handler (this, new ProjectTargetFrameworkChangedEventArgs (project));
			}
		}
		public UpdatedPackagesInProject (
			IDotNetProject project,
			IEnumerable<IPackageName> packages)
		{
			Project = project;
			this.packages = packages.ToList ();
		}
		public PackageManagementEventArgs (
			IDotNetProject project,
			PackageEventArgs e)
			: this (project, e.Identity, e.InstallPath)
		{
			PackageFilePath = GetPackageFilePath (e);
		}
		bool PackageNeedsReinstall (IDotNetProject project, IPackage package, FrameworkName packageTargetFramework)
		{
			var compatibility = new PackageCompatibility (project, package, packageTargetFramework);
			compatibility.CheckCompatibility ();
			compatibilityReport.Add (compatibility);

			return compatibility.ShouldReinstallPackage;
		}
		public TestableMonoDevelopProjectSystem (IDotNetProject project)
			: this (
				project,
				new FakeFileService (project),
				new FakePackageManagementProjectService (),
				new FakeLogger ())
		{
		}
		public TestableMonoDevelopProjectSystem (IDotNetProject project)
			: this (
				project,
				new FakeNuGetProjectContext (),
				new FakeFileService (project),
				new PackageManagementEvents ())
		{
		}
		public PackageManagementEventArgs (
			IDotNetProject project,
			PackageIdentity package,
			string installPath)
		{
			Project = project;
			Package = package;
			InstallPath = installPath;
		}
		public NuGetPackageEventsMonitor (
			IDotNetProject project,
			IPackageManagementEvents packageManagementEvents)
			: this (
				project,
				new PackageEventsProvider (),
				packageManagementEvents)
		{
		}
		public PackageCompatibilityRunner (
			IDotNetProject project,
			IPackageManagementProgressMonitorFactory progressMonitorFactory,
			IPackageManagementEvents packageManagementEvents)
		{
			this.project = project;
			this.progressMonitorFactory = progressMonitorFactory;
			this.packageManagementEvents = packageManagementEvents;
		}
		public ReinstallNuGetPackageAction (
			IDotNetProject project,
			IMonoDevelopSolutionManager solutionManager)
			: this (
				project,
				solutionManager,
				new NuGetProjectContext (),
				PackageManagementServices.PackageManagementEvents)
		{
		}
		UpdatedNuGetPackagesProvider CreateProvider (IDotNetProject project)
		{
			var solutionManager = GetSolutionManager (project.ParentSolution);
			var nugetProject = CreateNuGetProject (solutionManager, project);
			return new UpdatedNuGetPackagesProvider (
				project,
				solutionManager,
				nugetProject,
				cancellationTokenSource.Token);
		}
		public PackageCompatibilityRunner (IDotNetProject project)
			: this (
				project,
				PackageManagementServices.Solution,
				PackageManagementServices.RegisteredPackageRepositories,
				PackageManagementServices.ProgressMonitorFactory,
				PackageManagementServices.PackageManagementEvents,
				PackageManagementServices.ProgressProvider)
		{
		}
		public TestableAllPackagesViewModel (
			IMonoDevelopSolutionManager solutionManager,
			IDotNetProject dotNetProject,
			FakeNuGetProjectContext projectContext,
			RecentNuGetPackagesRepository recentPackagesRepository)
			: base (solutionManager, dotNetProject, projectContext, recentPackagesRepository)
		{
			FakeNuGetProjectContext = projectContext;
			RecentPackagesRepository = recentPackagesRepository;
		}
		public TestableAllPackagesViewModel (
			IMonoDevelopSolutionManager solutionManager,
			IDotNetProject dotNetProject)
			: this (
				solutionManager,
				dotNetProject,
				new FakeNuGetProjectContext (),
				new RecentNuGetPackagesRepository ())
		{
		}
		public UpdateNuGetPackageAction (
			IMonoDevelopSolutionManager solutionManager,
			IDotNetProject dotNetProject)
			: this (
				solutionManager,
				dotNetProject,
				new NuGetProjectContext (),
				new MonoDevelopNuGetPackageManager (solutionManager),
				PackageManagementServices.PackageManagementEvents)
		{
		}
		protected ProjectPackagesFolderNode (
			IDotNetProject project,
			IUpdatedNuGetPackagesInWorkspace updatedPackagesInWorkspace,
			bool createNuGetProject)
		{
			this.project = project;
			this.updatedPackagesInWorkspace = updatedPackagesInWorkspace;

			if (createNuGetProject)
				CreateInitNuGetProject ();
		}
Пример #20
0
 public AllPackagesViewModel(
     IMonoDevelopSolutionManager solutionManager,
     IDotNetProject dotNetProject,
     RecentNuGetPackagesRepository recentPackagesRepository)
     : this(
         solutionManager,
         dotNetProject,
         new NuGetProjectContext(),
         recentPackagesRepository)
 {
 }
Пример #21
0
 TestableMonoDevelopProjectSystem(
     IDotNetProject project,
     FakeNuGetProjectContext context,
     IPackageManagementFileService fileService,
     PackageManagementEvents packageManagementEvents)
     : base(project, context, fileService, packageManagementEvents, GuiSyncDispatcher, GuiSyncDispatcherFunc)
 {
     FakeNuGetProjectContext = context;
     FakeFileService         = (FakeFileService)fileService;
     PackageManagementEvents = packageManagementEvents;
 }
 public SharpDevelopProjectSystem(
     IDotNetProject project,
     IPackageManagementFileService fileService,
     IPackageManagementProjectService projectService,
     Action <MessageHandler> guiSyncDispatcher)
     : base(AppendTrailingSlashToDirectory(project.BaseDirectory))
 {
     this.project           = project;
     this.fileService       = fileService;
     this.guiSyncDispatcher = guiSyncDispatcher;
 }
Пример #23
0
        static string GetPackagesPath(ISettings settings, IDotNetProject project)
        {
            string packagesPath = project.EvaluatedProperties.GetValue("RestorePackagesPath");

            if (!string.IsNullOrEmpty(packagesPath))
            {
                return(MSBuildProjectService.FromMSBuildPath(project.BaseDirectory, packagesPath));
            }

            return(SettingsUtility.GetGlobalPackagesFolder(settings));
        }
Пример #24
0
 TestableMonoDevelopProjectSystem(
     IDotNetProject project,
     IPackageManagementFileService fileService,
     IPackageManagementProjectService projectService,
     FakeLogger logger)
     : base(project, fileService, projectService, GuiSyncDispatcher)
 {
     FakeFileService    = (FakeFileService)fileService;
     FakeProjectService = (FakePackageManagementProjectService)projectService;
     Logger             = logger;
 }
		public TestablePackageCompatibilityRunner (
			IDotNetProject project,
			IPackageManagementProgressMonitorFactory progressMonitorFactory,
			IPackageManagementEvents packageManagementEvents)
			: base (
				project,
				progressMonitorFactory,
				packageManagementEvents)
		{
			PackageReferenceFile = new PackageReferenceFile (FileSystem, "packages.config");
		}
		TestableMonoDevelopProjectSystem (
			IDotNetProject project,
			FakeNuGetProjectContext context,
			IPackageManagementFileService fileService,
			PackageManagementEvents packageManagementEvents)
			: base (project, context, fileService, packageManagementEvents, GuiSyncDispatcher, GuiSyncDispatcherFunc)
		{
			FakeNuGetProjectContext = context;
			FakeFileService = (FakeFileService)fileService;
			PackageManagementEvents = packageManagementEvents;
		}
 public TestablePackageCompatibilityRunner(
     IDotNetProject project,
     IPackageManagementProgressMonitorFactory progressMonitorFactory,
     IPackageManagementEvents packageManagementEvents)
     : base(
         project,
         progressMonitorFactory,
         packageManagementEvents)
 {
     PackageReferenceFile = new PackageReferenceFile(FileSystem, "packages.config");
 }
Пример #28
0
        void ProjectRemoved(object sender, DotNetProjectEventArgs e)
        {
            MonitoredSolution monitoredSolution = FindMonitoredSolution((ISolution)sender);
            IDotNetProject    matchedProject    = monitoredSolution.Projects.FirstOrDefault(project => project.Equals(e.Project));

            if (matchedProject != null)
            {
                matchedProject.Modified -= ProjectModified;
                monitoredSolution.Projects.Remove(matchedProject);
            }
        }
Пример #29
0
        public NuGetProject GetNuGetProject(IDotNetProject project)
        {
            FakeNuGetProject nugetProject = null;

            if (NuGetProjects.TryGetValue(project, out nugetProject))
            {
                return(nugetProject);
            }

            return(new FakeNuGetProject(project));
        }
Пример #30
0
 public static bool HasProjectType(this IDotNetProject project, Guid projectTypeGuid)
 {
     foreach (string guid in project.FlavorGuids)
     {
         if (IsMatch(projectTypeGuid, guid))
         {
             return(true);
         }
     }
     return(false);
 }
Пример #31
0
 static ProjectRestoreMetadata CreateRestoreMetadata(PackageSpec packageSpec, IDotNetProject project)
 {
     return(new ProjectRestoreMetadata {
         ProjectStyle = ProjectStyle.PackageReference,
         ProjectPath = project.FileName,
         ProjectName = packageSpec.Name,
         ProjectUniqueName = project.FileName,
         OutputPath = project.BaseIntermediateOutputPath,
         OriginalTargetFrameworks = GetOriginalTargetFrameworks(project).ToList()
     });
 }
Пример #32
0
        public UpdatedNuGetPackagesInProject GetUpdatedPackages(IDotNetProject project)
        {
            UpdatedNuGetPackagesInProject updatedPackages = projectsWithUpdatedPackages
                                                            .FirstOrDefault(item => item.Project.Equals(project));

            if (updatedPackages != null)
            {
                return(updatedPackages);
            }
            return(new UpdatedNuGetPackagesInProject(project));
        }
Пример #33
0
        UpdatedNuGetPackagesProvider CreateProvider(IDotNetProject project)
        {
            var solutionManager = GetSolutionManager(project.ParentSolution);
            var nugetProject    = CreateNuGetProject(solutionManager, project);

            return(new UpdatedNuGetPackagesProvider(
                       project,
                       solutionManager,
                       nugetProject,
                       cancellationTokenSource.Token));
        }
		TestableMonoDevelopProjectSystem (
			IDotNetProject project,
			IPackageManagementFileService fileService,
			IPackageManagementProjectService projectService,
			FakeLogger logger)
			: base (project, fileService, projectService, GuiSyncDispatcher)
		{
			FakeFileService = (FakeFileService)fileService;
			FakeProjectService = (FakePackageManagementProjectService)projectService;
			Logger = logger;
		}
 public UninstallNuGetPackagesAction(
     IMonoDevelopSolutionManager solutionManager,
     IDotNetProject dotNetProject)
     : this(
         solutionManager,
         dotNetProject,
         new NuGetProjectContext(),
         new MonoDevelopNuGetPackageManager(solutionManager),
         PackageManagementServices.PackageManagementEvents)
 {
 }
 public UpdateNuGetPackageAction(
     IMonoDevelopSolutionManager solutionManager,
     IDotNetProject dotNetProject)
     : this(
         solutionManager,
         dotNetProject,
         new NuGetProjectContext(solutionManager.Settings),
         new MonoDevelopNuGetPackageManager(solutionManager),
         PackageManagementServices.PackageManagementEvents)
 {
 }
Пример #37
0
        static IEnumerable <string> GetPackageTargetFallbackList(IDotNetProject project)
        {
            var properties = project.EvaluatedProperties;

            if (properties != null)
            {
                return(MSBuildStringUtility.Split(properties.GetValue("PackageTargetFallback")));
            }

            return(new string[0]);
        }
        public void GetProject_PackagesRepositoryAndProjectPassed_CreatesProjectUsingProjectPassed()
        {
            CreateSolution();
            FakeDotNetProject expectedProject = AddProjectToOpenProjects("Test");
            var repository = new FakePackageRepository();

            solution.GetProject(repository, expectedProject);

            IDotNetProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;

            Assert.AreEqual(expectedProject, project);
        }
Пример #39
0
 public UpdatePackagesProgressMonitorStatusMessage(
     IDotNetProject project,
     string packagesUpToDateMessage,
     string packagesUpToDateWarningMessage,
     ProgressMonitorStatusMessage message)
     : this(
         new IDotNetProject [] { project },
         packagesUpToDateMessage,
         packagesUpToDateWarningMessage,
         message)
 {
 }
        public void GetProjects_SolutionHasOneProject_MSBuildProjectUsedToCreateProject()
        {
            CreateSolution();
            FakeDotNetProject expectedProject = AddProjectToOpenProjects("MyProject");
            var repository = new FakePackageRepository();

            solution.GetProjects(repository).ToList();

            IDotNetProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;

            Assert.AreEqual(expectedProject, project);
        }
		protected override InstallNuGetPackageAction CreateInstallAction (
			IMonoDevelopSolutionManager solutionManager,
			IDotNetProject project,
			IEnumerable<SourceRepository> repositories)
		{
			InstallAction = new TestableInstallNuGetPackageAction (
				repositories,
				(FakeSolutionManager)solutionManager,
				(FakeDotNetProject)project);

			return InstallAction;
		}
        public void GetProject_PackagesSourceAndProjectNameWithDifferentCasePassed_CreatesProjectUsingFoundProjectMatchingName()
        {
            CreateSolution();
            FakeDotNetProject expectedProject = AddProjectToOpenProjects("Test");
            var source = new PackageSource("http://sharpdevelop.net");

            solution.GetProject(source, "TEST");

            IDotNetProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;

            Assert.AreEqual(expectedProject, project);
        }
		public UpdatePackagesProgressMonitorStatusMessage (
			IDotNetProject project,
			string packagesUpToDateMessage,
			string packagesUpToDateWarningMessage,
			ProgressMonitorStatusMessage message)
			: this (
				new IDotNetProject [] { project },
				packagesUpToDateMessage,
				packagesUpToDateWarningMessage,
				message)
		{
		}
        public void GetProject_RepositoryAndProjectNameWithDifferentCasePassed_CreatesProjectUsingFoundProjectMatchingName()
        {
            CreateSolution();
            FakeDotNetProject expectedProject = AddProjectToOpenProjects("Test");
            var repository = new FakePackageRepository();

            solution.GetProject(repository, "TEST");

            IDotNetProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;

            Assert.AreEqual(expectedProject, project);
        }
        protected override InstallNuGetPackageAction CreateInstallAction(
            IMonoDevelopSolutionManager solutionManager,
            IDotNetProject project,
            IEnumerable <SourceRepository> repositories)
        {
            InstallAction = new TestableInstallNuGetPackageAction(
                repositories,
                (FakeSolutionManager)solutionManager,
                (FakeDotNetProject)project);

            return(InstallAction);
        }
 protected virtual InstallNuGetPackageAction CreateInstallAction(
     IMonoDevelopSolutionManager solutionManager,
     IDotNetProject project,
     IEnumerable <SourceRepository> repositories)
 {
     return(new InstallNuGetPackageAction(
                repositories,
                solutionManager,
                project,
                context
                ));
 }
Пример #47
0
		public PackageManagementProject (
			IPackageRepository sourceRepository,
			IDotNetProject project,
			IPackageManagementEvents packageManagementEvents,
			IPackageManagerFactory packageManagerFactory)
		{
			SourceRepository = sourceRepository;
			this.project = project;
			this.packageManagementEvents = packageManagementEvents;
			
			packageManager = packageManagerFactory.CreatePackageManager (sourceRepository, project);
			projectManager = packageManager.ProjectManager;
		}
Пример #48
0
        public virtual IPackageManagementProject GetProject(IPackageRepository sourceRepository, IDotNetProject project)
        {
            RepositoryPassedToGetProject = sourceRepository;
            ProjectPassedToGetProject    = project;
            ProjectsPassedToGetProject.Add(project);
            FakePackageManagementProject fakeProject = null;

            if (FakeProjectsToReturnFromGetProject.TryGetValue(project.Name, out fakeProject))
            {
                return(fakeProject);
            }
            return(FakeProjectToReturnFromGetProject);
        }
        public void Execute_NoActions_NoUpdateFoundEventFires()
        {
            CreateAction();
            IDotNetProject noUpdateFoundForProject = null;

            packageManagementEvents.NoUpdateFound += (sender, e) => {
                noUpdateFoundForProject = e.Project;
            };

            action.Execute();

            Assert.AreEqual(project, noUpdateFoundForProject);
        }
 public InstallNuGetPackageAction(
     IEnumerable <SourceRepository> primarySources,
     IMonoDevelopSolutionManager solutionManager,
     IDotNetProject dotNetProject,
     INuGetProjectContext projectContext)
     : this(
         primarySources,
         null,
         solutionManager,
         dotNetProject,
         projectContext)
 {
 }
Пример #51
0
 public ManagePackagesViewModel(
     IMonoDevelopSolutionManager solutionManager,
     ISolution solution,
     RecentManagedNuGetPackagesRepository recentPackagesRepository,
     IDotNetProject project)
     : this(
         solutionManager,
         solution,
         new NuGetProjectContext(),
         recentPackagesRepository,
         project)
 {
 }
Пример #52
0
        public PackageManagementProject(
            IPackageRepository sourceRepository,
            IDotNetProject project,
            IPackageManagementEvents packageManagementEvents,
            IPackageManagerFactory packageManagerFactory)
        {
            SourceRepository             = sourceRepository;
            this.project                 = project;
            this.packageManagementEvents = packageManagementEvents;

            packageManager = packageManagerFactory.CreatePackageManager(sourceRepository, project);
            projectManager = packageManager.ProjectManager;
        }
		public NuGetPackageEventsMonitor (
			IDotNetProject project,
			IPackageEventsProvider provider,
			IPackageManagementEvents packageManagementEvents)
		{
			this.project = project;
			packageEvents = provider.GetPackageEvents ();
			this.packageManagementEvents = (PackageManagementEvents)packageManagementEvents;

			packageEvents.PackageInstalled += PackageInstalled;
			packageEvents.PackageUninstalling += PackageUninstalling;
			packageEvents.PackageUninstalled += PackageUninstalled;
		}
Пример #54
0
        void AddNuGetPackageReference(IDotNetProject project, string packageId)
        {
            var packageRepoFactory = new PackageRepositoryFactory();
            var packageRepo        = packageRepoFactory.CreateRepository("http://www.nuget.org/api/v2/");
            var packageManagementProjectFactory = new PackageManagementProjectFactory(PackageManagementServices.PackageManagementEvents);
            var packageManagementProject        = packageManagementProjectFactory.CreateProject(packageRepo, project);
            var package = packageRepo.FindPackagesById(packageId).FirstOrDefault(x => x.IsLatestVersion);
            var packageManagerFactory = new SharpDevelopPackageManagerFactory();
            var packageManager        = packageManagerFactory.CreatePackageManager(packageRepo, project);

            packageManager.InstallPackage(package, false, false);
            packageManagementProject.AddPackageReference(package);
        }
        internal static IDotNetProject ReadProjectLines([NotNull] this IDotNetProject dotNetProject)
        {
            using var sr = new StreamReader(dotNetProject.FileName);

            string line;

            while (!(line = sr.ReadLine()).IsEof())
            {
                dotNetProject.ProjectLines.Add(line.Trim());
            }

            return(dotNetProject);
        }
Пример #56
0
        /// <summary>
        /// Return the parsed version or 1.0.0 if the property does not exist.
        /// </summary>
        static NuGetVersion GetVersion(IDotNetProject project)
        {
            string versionString = project.EvaluatedProperties.GetValue("Version");

            if (string.IsNullOrEmpty(versionString))
            {
                // Default to 1.0.0 if the property does not exist
                return(new NuGetVersion(1, 0, 0));
            }

            // Snapshot versions are not allowed in .NETCore
            return(NuGetVersion.Parse(versionString));
        }
		public InstallNuGetPackageAction (
			IEnumerable<SourceRepository> primarySources,
			IMonoDevelopSolutionManager solutionManager,
			IDotNetProject dotNetProject,
			INuGetProjectContext projectContext)
			: this (
				primarySources,
				null,
				solutionManager,
				dotNetProject,
				projectContext)
		{
		}
		public ReinstallNuGetPackageAction (
			IDotNetProject project,
			IMonoDevelopSolutionManager solutionManager,
			INuGetProjectContext projectContext,
			IPackageManagementEvents packageManagementEvents)
		{
			this.context = projectContext;
			this.packageManagementEvents = packageManagementEvents;

			var repositories = solutionManager.CreateSourceRepositoryProvider ().GetRepositories ();

			installAction = CreateInstallAction (solutionManager, project, repositories);
			uninstallAction = CreateUninstallAction (solutionManager, project);
		}
		public UninstallNuGetPackageAction (
			IMonoDevelopSolutionManager solutionManager,
			IDotNetProject dotNetProject,
			INuGetProjectContext projectContext,
			INuGetPackageManager packageManager,
			IPackageManagementEvents packageManagementEvents)
		{
			this.dotNetProject = dotNetProject;
			this.context = projectContext;
			this.packageManager = packageManager;
			this.packageManagementEvents = packageManagementEvents;

			project = solutionManager.GetNuGetProject (dotNetProject);
		}
		public ISharpDevelopPackageManager CreatePackageManager(
			IPackageRepository sourceRepository,
			IDotNetProject project)
		{
			SolutionPackageRepository solutionPackageRepository = CreateSolutionPackageRepository (project.ParentSolution);
			IProjectSystem projectSystem = CreateProjectSystem (project.DotNetProject);
			PackageOperationsResolverFactory packageOperationResolverFactory = new PackageOperationsResolverFactory();
			
			return new SharpDevelopPackageManager(
				sourceRepository,
				projectSystem,
				solutionPackageRepository,
				packageOperationResolverFactory);
		}