/// <summary> /// Adds the plugin. /// </summary> /// <param name="projectService">The project service.</param> /// <param name="plugin">The plugin.</param> /// <param name="folderName">Name of the folder.</param> /// <param name="extensionName">Name of the extension.</param> /// <returns>True or false.</returns> public bool AddPlugin( IProjectService projectService, Plugin plugin, string folderName, string extensionName) { TraceService.WriteLine("PluginService::AddPlugin " + plugin.FriendlyName); bool added = false; string projectPath = projectService.GetProjectPath(); string source = plugin.Source; string destination = string.Format(@"{0}\Lib\{1}", projectPath, plugin.FileName); CodeConfig codeConfig = this.codeConfigService.GetCodeConfig(projectService, plugin.FriendlyName, false); //// we need to work out if the user has requested that the plugin is added from nuget //// and also if the plugin can be added from nuget - currently not all can! bool addPluginFromLocalDisk = this.codeConfigService.UseLocalDiskCopy(codeConfig); //// at this moment we only want ot do the core as this plugin might not be //// supported in the ui project. if (extensionName == Settings.Core || extensionName == Settings.CoreTests) { added = this.AddCorePlugin( projectService, plugin, codeConfig, addPluginFromLocalDisk, destination, source); } else { //// now if we are not the core project we need to add the platform specific assemblies //// and the bootstrap item templates! string extensionSource = this.GetSourcePath(plugin, extensionName); string extensionDestination = this.GetPluginPath(extensionName, destination); if (this.fileSystem.File.Exists(extensionSource)) { //// if the plugin is supported add in the core library. added = this.AddUIPlugin( projectService, plugin.FriendlyName, source, destination, extensionSource, extensionDestination, addPluginFromLocalDisk); } } return added; }
/// <summary> /// Adds the plugin. /// </summary> /// <param name="plugin">The plugin.</param> public void AddPlugin(Plugin plugin) { this.listView.Items.Add(new ListViewItem { Text = plugin.FriendlyName, ImageIndex = 0, Tag = plugin, }); }
/// <summary> /// Requests the bootstrap file. /// </summary> /// <param name="projectService">The project service.</param> /// <param name="plugin">The plugin.</param> internal void RequestBootstrapFile( IProjectService projectService, Plugin plugin) { TraceService.WriteLine("PluginService::RequestBootstrapFile plugin=" + plugin.FriendlyName); CodeConfig codeConfig = this.codeConfigFactory.GetPluginConfig(plugin); string bootstrapFileName = this.codeConfigService.GetBootstrapFileName(codeConfig, plugin.FriendlyName); //// check if the file already exists IProjectItemService projectItemService = projectService.GetProjectItem(bootstrapFileName); if (projectItemService == null) { //// get the currently requested plugins. string currentPlugins = this.settingsService.PluginsToAdd; string newPlugins = currentPlugins + "+" + bootstrapFileName; //// and now save the new requested plugins. this.settingsService.PluginsToAdd = newPlugins; TraceService.WriteLine("***plugins for" + projectService.Name + " " + newPlugins); } }
/// <summary> /// Updates the plugin via nuget. /// </summary> /// <param name="projectService">The project service.</param> /// <param name="plugin">The plugin.</param> /// <returns>True if updated via nuget.</returns> internal string GetProjectNugetCommand( IProjectService projectService, Plugin plugin) { TraceService.WriteLine("PluginService::UpdateViaNuget plugin=" + plugin.FriendlyName); CodeConfig codeConfig = this.codeConfigFactory.GetPluginConfig(plugin); return this.codeConfigService.GetProjectNugetCommand(codeConfig, projectService); }
/// <summary> /// Adds the core. /// </summary> /// <param name="projectService">The project service.</param> /// <param name="plugin">The plugin.</param> /// <param name="codeConfig">The code config.</param> /// <param name="addPluginFromLocalDisk">if set to <c>true</c> [add plugin from local disk].</param> /// <param name="destination">The destination.</param> /// <param name="source">The source.</param> /// <returns>True or false.</returns> internal bool AddCorePlugin( IProjectService projectService, Plugin plugin, CodeConfig codeConfig, bool addPluginFromLocalDisk, string destination, string source) { TraceService.WriteLine("PluginService::AddCorePlugin plugin=" + plugin.FriendlyName); //// inform the user that we cant install from nuget. if (this.codeConfigService.NugetRequestedAndNotSupported(codeConfig)) { this.Messages.Add( plugin.FriendlyName + " plugin does not support being installed via Nuget and has been installed from the local machine."); } //// don't need to add reference if we are going to use nuget. if (addPluginFromLocalDisk) { //// only do if destination file doesn't exist if (this.fileSystem.File.Exists(destination) == false) { projectService.AddReference( "Lib", destination, source, this.settingsService.IncludeLibFolderInProjects, this.settingsService.CopyAssembliesToLibFolder); } } return true; }
/// <summary> /// Adds the non core plugin. /// </summary> /// <param name="projectService">The project service.</param> /// <param name="plugin">The plugin.</param> /// <param name="source">The source.</param> /// <param name="destination">The destination.</param> /// <param name="extensionSource">The extension source.</param> /// <param name="extensionDestination">The extension destination.</param> /// <param name="addPluginFromLocalDisk">if set to <c>true</c> [add plugin from local disk].</param> /// <returns> /// True or false. /// </returns> public bool AddUIPlugin( IProjectService projectService, Plugin plugin, string source, string destination, string extensionSource, string extensionDestination, bool addPluginFromLocalDisk) { TraceService.WriteLine("PluginService::AddUIPlugin plugin=" + plugin.FriendlyName); bool added = false; string[] projectNameParts = projectService.Name.Split('.'); //// we need to look for the ui specific config file, Plugin uiPlugin = new Plugin { FriendlyName = plugin.FriendlyName + "." + projectNameParts[1] }; CodeConfig codeConfig = this.codeConfigFactory.GetPluginConfig(uiPlugin); this.codeConfigService.ProcessCodeConfig( projectService, codeConfig, extensionSource, extensionDestination); //// only do if destination file doesn't exist if (this.fileSystem.File.Exists(destination) == false) { if (addPluginFromLocalDisk) { projectService.AddReference( "Lib", destination, source, this.settingsService.IncludeLibFolderInProjects, this.settingsService.CopyAssembliesToLibFolder); } } //// only do if extensionDestination file doesn't exist if (this.fileSystem.File.Exists(extensionDestination) == false) { if (addPluginFromLocalDisk) { projectService.AddReference( "Lib", extensionDestination, extensionSource, this.settingsService.IncludeLibFolderInProjects, this.settingsService.CopyAssembliesToLibFolder); } added = true; this.RequestBootstrapFile( projectService, plugin); } return added; }
/// <summary> /// Adds the project plugin. /// </summary> /// <param name="projectService">The project service.</param> /// <param name="folderName">Name of the folder.</param> /// <param name="extensionName">Name of the extension.</param> /// <param name="plugin">The plugin.</param> /// <returns>Returns true if plugin added.</returns> public bool AddProjectPlugin( IProjectService projectService, string folderName, string extensionName, Plugin plugin) { TraceService.WriteLine("PluginService::AddProjectPlugin folder=" + folderName); this.Messages.Clear(); string message = string.Format("Ninja Coder is adding {0} plugin to {1} project.", plugin.FriendlyName, projectService.Name); projectService.WriteStatusBarMessage(message); bool added = this.AddPlugin(projectService, plugin, extensionName); if (added) { //// if we want to add via nuget then generate the command. if (this.settingsService.UseNugetForPlugins) { string command = this.GetProjectNugetCommand(projectService, plugin); if (string.IsNullOrEmpty(command) == false) { if (this.settingsService.UsePreReleaseNugetPackages) { command += " " + NugetConstants.UsePreReleaseOption; } plugin.NugetCommands.Add(command); } } this.Messages.Add(plugin.FriendlyName + " plugin added to project " + projectService.Name + "."); } return added; }
public void TestGetSourcePathUserPlugin() { SettingsService settingsService = new SettingsService(); Plugin plugin = new Plugin { Source = settingsService.MvvmCrossAssembliesPath + @"\Cirrious.MvvmCross.Plugins.Accelerometer.dll", FileName = @"\Cirrious.MvvmCross.Plugins.Accelerometer.dll" }; this.mockSettingsService.SetupGet(x => x.MvvmCrossAssembliesOverrideDirectory) .Returns(settingsService.MvvmCrossAssembliesOverrideDirectory); this.mockFileInfo.FileName = "adrian.wpf"; this.mockFileInfo.FileExists = true; string path = this.service.GetSourcePath(plugin, "wpf"); Assert.IsTrue(path == @"adrian.wpf"); }
/// <summary> /// Adds the plugin. /// </summary> /// <param name="plugin">The plugin.</param> public void AddPlugin(Plugin plugin) { this.mvxListView1.AddPlugin(plugin); }
/// <summary> /// Gets the source path. /// </summary> /// <param name="plugin">The plugin.</param> /// <param name="extensionName">Name of the extension.</param> /// <returns>The plugin path.</returns> internal string GetSourcePath( Plugin plugin, string extensionName) { //// here we are look to see if the user has overridden the file in their own directory. string userDirectory = this.settingsService.MvvmCrossAssembliesOverrideDirectory; string userFilePath = this.GetPluginPath(extensionName, userDirectory + "\\" + plugin.FileName); FileInfoBase userFileInfoBase = this.fileSystem.FileInfo.FromFileName(userFilePath); string coreDirectory = this.settingsService.MvvmCrossAssembliesPath; FileInfoBase coreFileInfoBase = this.fileSystem.FileInfo.FromFileName(coreDirectory + "\\" + plugin.FileName); return userFileInfoBase.Exists ? userFileInfoBase.FullName : this.GetPluginPath(extensionName, coreFileInfoBase.FullName); }
public void TestGetPluginConfig() { Plugin plugin = new Plugin { FriendlyName = "File" }; MockFile mockFile = new MockFile(); this.mockFileSystem.SetupGet(x => x.File).Returns(mockFile); SettingsService settingsService = new SettingsService(); this.mockSettingsService.SetupGet(x => x.PluginsConfigPath).Returns(settingsService.PluginsConfigPath); this.mockSettingsService.SetupGet(x => x.UserCodeConfigPluginsPath).Returns(settingsService.UserCodeConfigPluginsPath); this.mockTranslator.Setup(x => x.Translate(It.IsAny<string>())).Returns(new CodeConfig()); this.factory.GetPluginConfig(plugin); this.mockTranslator.Verify(x => x.Translate(It.IsAny<string>())); }
/// <summary> /// Gets the plugin test snippet. /// </summary> /// <param name="plugin">The plugin.</param> /// <returns>The code snippet.</returns> public CodeSnippet GetPluginTestSnippet(Plugin plugin) { TraceService.WriteLine("CodeSnippetFactory::GetPluginTestSnippet pluign=" + plugin); string fileName = string.Format(@"Plugins.{0}.Tests.xml", plugin.FriendlyName); CodeSnippet codeSnippet = this.GetSnippet( this.settingsService.PluginsCodeSnippetsPath, this.settingsService.UserCodeSnippetsPluginsPath, fileName); this.BuildTestingSnippet(codeSnippet); return codeSnippet; }
/// <summary> /// Gets the plugin snippet. /// </summary> /// <param name="plugin">The plugin.</param> /// <returns> /// The code snippet. /// </returns> public CodeSnippet GetPluginSnippet(Plugin plugin) { TraceService.WriteLine("CodeSnippetFactory::GetPluginSnippet plugin=" + plugin.FriendlyName); string fileName = string.Format(@"Plugins.{0}.xml", plugin.FriendlyName); return this.GetSnippet( this.settingsService.PluginsCodeSnippetsPath, this.settingsService.UserCodeSnippetsPluginsPath, fileName); }
public void TestAddPluginToCore() { //// arrange Plugin plugin = new Plugin(); Mock<IProjectService> mockProjectService = new Mock<IProjectService>(); Mock<Project> mockProject = new Mock<Project>(); mockProjectService.SetupGet(x => x.Project).Returns(mockProject.Object); //// act this.service.AddPlugin( mockProjectService.Object, plugin, string.Empty, Settings.Core); //// assert mockProjectService.Verify(x => x.AddReference( It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>())); }
/// <summary> /// Adds the plugin. /// </summary> /// <param name="plugin">The plugin.</param> /// <param name="project">The project.</param> /// <param name="folderName">Name of the folder.</param> /// <param name="extensionName">Name of the extension.</param> internal void AddPlugin( Plugin plugin, Project project, string folderName, string extensionName) { string projectPath = project.GetProjectPath(); string source = plugin.Source; string destination = string.Format(@"{0}\Lib\{1}", projectPath, plugin.FileName); //// at this moment we only want ot do the core as this plugin might not be //// supported in the ui project. if (extensionName == "Core") { this.AddReference(project, destination, source); } else { //// now if we are not the core project we need to add the platform specific assemblies //// and the bootstrap item templates! string extensionSource = this.GetExtensionSource(folderName, extensionName, source); string extensionDestination = this.GetExtensionDestination(folderName, extensionName, destination); if (File.Exists(extensionSource)) { //// if the plugin is supported add in the core library. //// only do if destination file doesnt exist if (File.Exists(destination) == false) { this.AddReference(project, destination, source); } //// only do if extensionDestination file doesnt exist if (File.Exists(extensionDestination) == false) { this.AddReference(project, extensionDestination, extensionSource); this.BuildSourceFile(project, extensionSource, extensionDestination, plugin.FriendlyName); } } } }
public void TestAddPluginToNonCore() { //// arrange Plugin plugin = new Plugin { Source = "Here I am" }; Mock<IProjectService> mockProjectService = new Mock<IProjectService>(); Mock<Project> mockProject = new Mock<Project>(); mockProjectService.SetupGet(x => x.Project).Returns(mockProject.Object); this.mockFile.FileExists = true; //// act this.service.AddPlugin( mockProjectService.Object, plugin, "Test.Droid", Settings.Droid); //// assert mockProjectService.Verify( x => x.AddReference( It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Never()); }
/// <summary> /// Gets the plugin config. /// </summary> /// <param name="plugin">The plugin.</param> /// <returns>The code config.</returns> public CodeConfig GetPluginConfig(Plugin plugin) { TraceService.WriteLine("CodeConfigFactory::GetPluginConfig plugin=" + plugin.FriendlyName); string fileName = string.Format(@"Config.Plugin.{0}.xml", plugin.FriendlyName); return this.GetConfig( this.settingsService.PluginsConfigPath, this.settingsService.UserCodeConfigPluginsPath, fileName); }
public void TestGetPluginTestSnippet() { Plugin plugin = new Plugin(); MockFile mockFile = new MockFile { FileExists = true }; this.mockFileSystem.SetupGet(x => x.File).Returns(mockFile); SettingsService settingsService = new SettingsService(); this.mockSettingsService.SetupGet(x => x.PluginsCodeSnippetsPath).Returns(settingsService.PluginsCodeSnippetsPath); this.mockSettingsService.SetupGet(x => x.UserCodeSnippetsPluginsPath).Returns(settingsService.UserCodeSnippetsPluginsPath); this.mockTranslator.Setup(x => x.Translate(It.IsAny<string>())).Returns(new CodeSnippet()); this.factory.GetPluginTestSnippet(plugin); this.mockTranslator.Verify(x => x.Translate(It.IsAny<string>())); }
public void TestGetSourcePath() { SettingsService settingsService = new SettingsService(); Plugin plugin = new Plugin { Source = settingsService.MvvmCrossAssembliesPath + @"\Cirrious.MvvmCross.Plugins.Accelerometer.dll", FileName = @"\Cirrious.MvvmCross.Plugins.Accelerometer.dll" }; this.mockSettingsService.SetupGet(x => x.MvvmCrossAssembliesOverrideDirectory) .Returns(settingsService.MvvmCrossAssembliesOverrideDirectory); this.mockFileInfo.FileExists = false; string path = this.service.GetSourcePath(plugin, "wpf"); Assert.IsTrue(path == @"C:\Program Files (x86)\Scorchio Limited\Ninja Coder for MvvmCross\MvvmCross\Assemblies\\Cirrious.MvvmCross.Plugins.Accelerometer.wpf.dll"); }