/// <summary>
/// Applies the code dependencies.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="codeConfig">The code config.</param>
/// <returns>The messages.</returns>
public IEnumerable<string> ApplyCodeDependencies(
IVisualStudioService visualStudioService, CodeConfig codeConfig)
{
TraceService.WriteLine("CodeConfigService::ApplyCodeDependencies");
List<string> messages = new List<string>();
//// apply any code dependencies
foreach (CodeSnippet codeSnippet in codeConfig.CodeDependencies)
{
IEnumerable<string> snippetMessages = this.ApplyCodeSnippet(visualStudioService, codeSnippet);
messages.AddRange(snippetMessages);
}
return messages;
}
/// <summary>
/// Gets the name of the bootstrap file.
/// </summary>
/// <param name="codeConfig">The code config.</param>
/// <param name="friendlyName">Name of the friendly.</param>
/// <returns>The bootstrap file name.</returns>
public string GetBootstrapFileName(
CodeConfig codeConfig,
string friendlyName)
{
TraceService.WriteLine("CodeConfigService::GetBootstrapFileName name=" + friendlyName);
string bootstrapFileName = friendlyName + "PluginBootstrap.cs";
//// the bootstrap file name can be overridden in the code config file.
if (codeConfig != null &&
string.IsNullOrEmpty(codeConfig.BootstrapFileNameOverride) == false)
{
bootstrapFileName = codeConfig.BootstrapFileNameOverride;
TraceService.WriteLine("bootstrapFile has been overidden filename=" + bootstrapFileName);
}
return bootstrapFileName;
}
/// <summary>
/// Gets the nuget command.
/// </summary>
/// <param name="codeConfig">The code config.</param>
/// <returns>The nuget command.</returns>
public string GetNugetCommand(CodeConfig codeConfig)
{
TraceService.WriteLine("CodeConfigService::GetNugetCommand");
if (codeConfig != null &&
string.IsNullOrEmpty(codeConfig.NugetPackage) == false)
{
return codeConfig.NugetPackage;
}
return string.Empty;
}
/// <summary>
/// Processes the config.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="projectService">The project service.</param>
/// <param name="codeConfig">The code config.</param>
internal void ProcessConfig(
IVisualStudioService visualStudioService,
IProjectService projectService,
CodeConfig codeConfig)
{
TraceService.WriteLine("ServicesService::ProcessConfig");
if (codeConfig != null)
{
//// do we have any dependent plugins?
codeConfig.DependentPlugins.ForEach(x => this.AddDependantPlugin(visualStudioService, x));
string sourceDirectory = this.settingsService.MvvmCrossAssembliesPath;
//// don't need to add reference if we are going to use nuget.
if (this.settingsService.UseNugetForServices == false)
{
foreach (string reference in codeConfig.References)
{
projectService.AddReference(
"Lib",
projectService.GetProjectPath() + @"\Lib\" + reference,
sourceDirectory + @"\" + reference,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder);
}
}
//// if we want to add via nuget then generate the command.
if (this.settingsService.UseNugetForServices ||
codeConfig.NugetInstallationMandatory == "Y")
{
////this.nugetService.UpdateViaNuget(projectService, codeConfig);
}
//// apply any code dependencies
IEnumerable<string> messages = this.codeConfigService.ApplyCodeDependencies(
visualStudioService,
codeConfig);
this.Messages.AddRange(messages);
}
}
/// <summary>
/// Gets the project nuget command if we need one.
/// </summary>
/// <param name="codeConfig">The code config.</param>
/// <param name="projectService">The project service.</param>
/// <returns>The nuget command if applicable.</returns>
public string GetProjectNugetCommand(
CodeConfig codeConfig,
IProjectService projectService)
{
TraceService.WriteLine("CodeConfigService::GetProjectNugetCommand");
string command = string.Empty;
string nugetCommand = this.GetNugetCommand(codeConfig);
if (string.IsNullOrEmpty(nugetCommand) == false)
{
command = Settings.NugetInstallPackage.Replace("%s", nugetCommand);
//// need to add the project to the end of the command!
command += string.Format(" {0}", projectService.Name);
TraceService.WriteLine("Command=" + command);
}
return command;
}
/// <summary>
/// Processes the code config.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="codeConfig">The code config.</param>
/// <param name="extensionSource">The extension source.</param>
/// <param name="extensionDestination">The extension destination.</param>
public void ProcessCodeConfig(
IProjectService projectService,
CodeConfig codeConfig,
string extensionSource,
string extensionDestination)
{
TraceService.WriteLine("CodeConfigService::ProcessCodeConfig");
if (codeConfig != null)
{
//// process it if we are using local disk copy.
if (this.UseLocalDiskCopy(codeConfig))
{
string sourceDirectory = this.fileSystem.Path.GetDirectoryName(extensionSource);
string destinationDirectory = this.fileSystem.Path.GetDirectoryName(extensionDestination);
codeConfig.References.ForEach(
x => projectService.AddReference(
"Lib",
destinationDirectory + @"\" + x,
sourceDirectory + @"\" + x,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder));
}
}
}
public void TestUseLocalDiskCopyWhenNugetRequested()
{
this.mockSettingsService.SetupGet(x => x.UseNugetForPlugins).Returns(true);
CodeConfig codeConfig = new CodeConfig();
bool useLocalCopy = this.service.UseLocalDiskCopy(codeConfig);
Assert.IsTrue(useLocalCopy);
}
public void TestProcessConfig()
{
Mock<IVisualStudioService> mockVisualStudioService = new Mock<IVisualStudioService>();
Mock<IProjectService> mockProjectService = new Mock<IProjectService>();
mockVisualStudioService.SetupGet(x => x.CoreProjectService)
.Returns(mockProjectService.Object);
CodeConfig codeConfig = new CodeConfig();
service.ProcessConfig(
mockVisualStudioService.Object,
mockProjectService.Object,
codeConfig);
}
public void TestNugetRequestedAndNotSupportedTrue()
{
this.mockSettingsService.SetupGet(x => x.UseNugetForPlugins).Returns(true);
CodeConfig codeConfig = new CodeConfig();
bool supported = this.service.NugetRequestedAndNotSupported(codeConfig);
Assert.IsTrue(supported);
}
/// <summary>
/// Uses the local disk copy.
/// </summary>
/// <param name="codeConfig">The code config.</param>
/// <returns>True or false.</returns>
public bool UseLocalDiskCopy(CodeConfig codeConfig)
{
return this.settingsService.UseNugetForPlugins == false ||
string.IsNullOrEmpty(this.GetNugetCommand(codeConfig));
}
/// <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>
/// Nuget has been requested and is not supported.
/// </summary>
/// <param name="codeConfig">The code config.</param>
/// <returns>True or false.</returns>
public bool NugetRequestedAndNotSupported(CodeConfig codeConfig)
{
return this.settingsService.UseNugetForPlugins &&
string.IsNullOrEmpty(this.GetNugetCommand(codeConfig));
}
/// <summary>
/// Updates the service via nuget.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="codeConfig">The code config.</param>
/// <returns>True if updated via nuget.</returns>
internal bool UpdateServiceViaNuget(
IProjectService projectService,
CodeConfig codeConfig)
{
TraceService.WriteLine("ServicesService::UpdateViaNuget");
return this.UpdateViaNuget(projectService, codeConfig);
}
/// <summary>
/// Applies the code dependencies.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="codeConfig">The code config.</param>
internal void ApplyCodeDependencies(
IVisualStudioService visualStudioService,
CodeConfig codeConfig)
{
TraceService.WriteLine("ServicesService::ApplyCodeDependencies");
//// apply any code dependencies
if (codeConfig.CodeDependencies != null)
{
foreach (CodeSnippet codeSnippet in codeConfig.CodeDependencies)
{
//// find the project
IProjectService projectService = visualStudioService.GetProjectServiceBySuffix(codeSnippet.Project);
if (projectService != null)
{
//// find the class
IProjectItemService projectItemService = projectService.GetProjectItem(codeSnippet.Class + ".cs");
if (projectItemService != null)
{
//// find the method.
CodeFunction codeFunction = projectItemService.GetFirstClass().GetFunction(codeSnippet.Method);
if (codeFunction != null)
{
string code = codeFunction.GetCode();
if (code.Contains(codeSnippet.Code.Trim()) == false)
{
codeFunction.InsertCode(codeSnippet.Code, true);
string message = string.Format(
"Code added to project {0} class {1} method {2}.",
projectService.Name,
codeSnippet.Class,
codeSnippet.Method);
this.Messages.Add(message);
}
}
}
}
}
}
}
public void TestProcessCodeConfig()
{
SettingsService settingsService = new SettingsService();
this.mockSettingsService.SetupGet(x => x.ConfigPath).Returns(settingsService.ConfigPath);
Mock<IProjectService> mockProjectService = new Mock<IProjectService>();
mockProjectService.SetupGet(x => x.Name).Returns("Adrian.WindowsPhone");
CodeConfig codeConfig = new CodeConfig
{
References = new List<string> { "test" }
};
MockPathBase mockPathBase = new MockPathBase();
this.mockFileSystem.SetupGet(x => x.Path).Returns(mockPathBase);
////this.mockSettingsService.SetupGet(x => x.UseNugetForPlugins).Returns(false);
/*this.service.ProcessCodeConfig(mockProjectService.Object, "SQLite", "source", "destination");
mockProjectService.Verify(
x => x.AddReference(
It.IsAny<string>(),
It.IsAny<string>(),
It.IsAny<string>(),
It.IsAny<bool>(),
It.IsAny<bool>()));*/
}
public void TestUseLocalDiskCopyShouldBeFalse()
{
this.mockSettingsService.SetupGet(x => x.UseNugetForPlugins).Returns(true);
CodeConfig codeConfig = new CodeConfig
{
NugetPackage = "nugetPackage"
};
bool useLocalCopy = this.service.UseLocalDiskCopy(codeConfig);
Assert.IsTrue(!useLocalCopy);
}
public void TestGetBootstrapFileNameIsOveridden()
{
CodeConfig codeConfig = new CodeConfig
{
BootstrapFileNameOverride = "OverrideBootstrap.cs"
};
string fileName = this.service.GetBootstrapFileName(codeConfig, "friendlyName");
Assert.IsTrue(fileName == "OverrideBootstrap.cs");
}
/// <summary>
/// Updates the via nuget.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="codeConfig">The code config.</param>
/// <returns>True if updated via nuget.</returns>
internal bool UpdateViaNuget(
IProjectService projectService,
CodeConfig codeConfig)
{
TraceService.WriteLine("BaseCodeService::UpdateViaNuget");
bool updated = false;
if (codeConfig != null &&
string.IsNullOrEmpty(codeConfig.NugetPackage) == false)
{
string command = Settings.NugetInstallPackage.Replace("%s", codeConfig.NugetPackage);
//// need to add the project to the end of the command!
command += string.Format(" {0}", projectService.Name);
this.NugetCommands.Add(command);
updated = true;
}
return updated;
}
