public IEnumerable <ITemplate> GetTemplatesFromSource(IConfiguredTemplateSource source)
{
using (IDisposable <ITemplateSourceFolder> root = source.Root)
{
return(GetTemplatesFromDir(source, root.Value).ToList());
}
}
private IEnumerable <ITemplate> GetTemplatesFromDir(IConfiguredTemplateSource source, ITemplateSourceFolder folder)
{
foreach (ITemplateSourceEntry entry in folder.Children)
{
if (entry.Kind == TemplateSourceEntryKind.File && entry.FullPath.EndsWith(".vstemplate"))
{
VsTemplate tmp = null;
try
{
tmp = new VsTemplate((ITemplateSourceFile)entry, source, this);
}
catch
{
}
if (tmp != null)
{
yield return(tmp);
}
}
else if (entry.Kind == TemplateSourceEntryKind.Folder)
{
foreach (ITemplate template in GetTemplatesFromDir(source, (ITemplateSourceFolder)entry))
{
yield return(template);
}
}
}
}
private static void Scan(IConfiguredTemplateSource configuredSource, IReadOnlyList <ITemplateSource> fileEmbeddableSources, Dictionary <string, IConfiguredTemplateSource> configuredSources)
{
using (IDisposable <ITemplateSourceFolder> rootFolder = configuredSource.Root)
{
foreach (ITemplateSourceFile entry in rootFolder.Value.EnumerateFiles("*", SearchOption.AllDirectories))
{
if (entry.Kind == TemplateSourceEntryKind.File)
{
foreach (ITemplateSource source in fileEmbeddableSources)
{
if (source.CanHandle(configuredSource, entry.FullPath))
{
IConfiguredTemplateSource embedded = new EmbeddedTemplateSource(configuredSource, entry, source);
configuredSources[embedded.Location] = embedded;
if (embedded.Source.CanHostEmbeddedSources)
{
Scan(embedded, fileEmbeddableSources, configuredSources);
}
}
}
}
}
}
}
public bool CanHandle(IConfiguredTemplateSource source, string location)
{
try
{
string extension = Path.GetExtension(location).ToUpperInvariant();
switch (extension)
{
case ".ZIP":
case ".VSIX":
case ".NUPKG":
break;
default:
return(false);
}
using (Stream fileData = source.Root.Value.OpenFile(location))
using (new ZipArchive(fileData, ZipArchiveMode.Read, true))
{
}
return(true);
}
catch
{
return(false);
}
}
public VsTemplate(ITemplateSourceFile source, IConfiguredTemplateSource templateSource, IGenerator generator)
{
SourceFile = source;
Source = templateSource;
Generator = generator;
using (Stream src = source.OpenRead())
{
XDocument doc = XDocument.Load(src);
DefaultName = doc.Root.Descendants().FirstOrDefault(x => x.Name.LocalName == "DefaultName")?.Value;
XElement idElement = doc.Root.Descendants().FirstOrDefault(x => x.Name.LocalName == "TemplateID");
IEnumerable <XElement> customParameters = doc.Root.Descendants().Where(x => x.Name.LocalName == "CustomParameter");
List <CustomParameter> declaredParams = new List <CustomParameter>();
foreach (XElement parameter in customParameters)
{
string name = parameter.Attributes().First(x => x.Name.LocalName == "Name").Value;
name = name.Substring(1, name.Length - 2);
declaredParams.Add(new CustomParameter
{
Name = name,
DefaultValue = parameter.Attributes().First(x => x.Name.LocalName == "Value").Value
});
}
CustomParameters = declaredParams;
Name = idElement.Value;
VsTemplateFile = doc;
}
}
public IDisposable <ITemplateSourceFolder> RootFor(IConfiguredTemplateSource source, string location)
{
if (!source.Root.Value.Exists(location))
{
return(Directory.Empty.NoDispose());
}
return(new Directory(null, "", "", () => new ZipArchive(source.Root.Value.OpenFile(location), ZipArchiveMode.Read, false)).NoDispose());
}
public RunnableProjectTemplate(JObject raw, IGenerator generator, IConfiguredTemplateSource source, ITemplateSourceFile configFile, IRunnableProjectConfig config)
{
config.SourceFile = configFile;
ConfigFile = configFile;
Generator = generator;
Source = source;
Config = config;
DefaultName = config.DefaultName;
Name = config.Name;
Identity = config.Identity ?? config.Name;
ShortName = config.ShortName;
Author = config.Author;
Tags = config.Tags;
Classifications = config.Classifications;
GroupIdentity = config.GroupIdentity;
_raw = raw;
}
public string GetInstallPackageId(IConfiguredTemplateSource source, string location)
{
if (Path.GetExtension(location).ToUpperInvariant() == ".NUPKG")
{
using (IDisposable <ITemplateSourceFolder> root = RootFor(source, location))
{
ITemplateSourceFile nuspec = root.Value.EnumerateFiles("*.nuspec", SearchOption.TopDirectoryOnly).FirstOrDefault();
if (nuspec != null)
{
string id, version;
GetPackageIdAndVersion(nuspec, out id, out version);
return(id);
}
}
}
return(null);
}
public static IReadOnlyCollection <ITemplate> List(string searchString, CommandOption source)
{
HashSet <ITemplate> results = new HashSet <ITemplate>(TemplateEqualityComparer.Default);
IReadOnlyList <IConfiguredTemplateSource> searchSources;
if (!source.HasValue())
{
searchSources = Program.Broker.GetConfiguredSources().ToList();
}
else
{
IConfiguredTemplateSource realSource = Program.Broker.GetConfiguredSources().FirstOrDefault(x => x.Alias == source.Value());
if (realSource == null)
{
return(results);
}
searchSources = new List <IConfiguredTemplateSource> {
realSource
};
}
searchSources = ConfiguredTemplateSourceHelper.Scan(searchSources, Program.Broker.ComponentRegistry.OfType <ITemplateSource>());
foreach (IGenerator gen in Program.Broker.ComponentRegistry.OfType <IGenerator>())
{
foreach (IConfiguredTemplateSource target in searchSources)
{
results.UnionWith(gen.GetTemplatesFromSource(target));
}
}
IReadOnlyCollection <ITemplate> aliasResults = AliasRegistry.GetTemplatesForAlias(searchString, results);
if (!string.IsNullOrWhiteSpace(searchString))
{
results.RemoveWhere(x => x.Name.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) < 0 && (x.ShortName?.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) ?? -1) < 0);
}
results.UnionWith(aliasResults);
return(results);
}
private IEnumerable <ITemplate> GetTemplatesFromDir(IConfiguredTemplateSource source, ITemplateSourceFolder folder)
{
foreach (ITemplateSourceEntry entry in folder.Children)
{
if (entry.Kind == TemplateSourceEntryKind.File && entry.Name.Equals(".netnew.json", StringComparison.OrdinalIgnoreCase))
{
RunnableProjectTemplate tmp = null;
try
{
ITemplateSourceFile file = (ITemplateSourceFile)entry;
JObject srcObject = ReadConfigModel(file);
tmp = new RunnableProjectTemplate(srcObject, this, source, file, srcObject.ToObject <IRunnableProjectConfig>(new JsonSerializer
{
Converters =
{
new RunnableProjectConfigConverter()
}
}));
}
catch
{
}
if (tmp != null)
{
yield return(tmp);
}
}
else if (entry.Kind == TemplateSourceEntryKind.Folder)
{
foreach (ITemplate template in GetTemplatesFromDir(source, (ITemplateSourceFolder)entry))
{
yield return(template);
}
}
}
}
public async Task <bool> CheckForUpdatesAsync(IConfiguredTemplateSource source, string location)
{
if (Path.GetExtension(location).ToUpperInvariant() == ".NUPKG")
{
using (IDisposable <ITemplateSourceFolder> root = RootFor(source, location))
{
ITemplateSourceFile nuspec = root.Value.EnumerateFiles("*.nuspec", SearchOption.TopDirectoryOnly).FirstOrDefault();
if (nuspec != null)
{
string id, version;
GetPackageIdAndVersion(nuspec, out id, out version);
NuGetUtil.Init();
string newerVersion = await NuGetUtil.GetCurrentVersionOfPackageAsync(id, version);
return(newerVersion != null);
}
}
}
return(false);
}
public EmbeddedTemplateSource(IConfiguredTemplateSource parent, ITemplateSourceEntry entry, ITemplateSource source)
{
_parent = parent;
_entry = entry;
_source = source;
}
public IDisposable <ITemplateSourceFolder> RootFor(IConfiguredTemplateSource source, string location)
{
return(null);
}
public Task <bool> CheckForUpdatesAsync(IConfiguredTemplateSource source, string location)
{
return(Task.FromResult(false));
}
public bool TryGetTemplateFromSource(IConfiguredTemplateSource target, string name, out ITemplate template)
{
template = GetTemplatesFromSource(target).FirstOrDefault(x => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase));
return(template != null);
}
public string GetInstallPackageId(IConfiguredTemplateSource source, string location)
{
return(null);
}
public bool CanHandle(IConfiguredTemplateSource source, string location)
{
return(false);
}
private static bool TryGetTemplate(string templateName, CommandOption source, bool quiet, out ITemplate tmplt, out IGenerator generator)
{
IReadOnlyList <IConfiguredTemplateSource> searchSources;
if (!source.HasValue())
{
searchSources = Program.Broker.GetConfiguredSources().ToList();
}
else
{
IConfiguredTemplateSource realSource = Program.Broker.GetConfiguredSources().FirstOrDefault(x => x.Alias == source.Value());
if (realSource == null)
{
tmplt = null;
generator = null;
return(false);
}
searchSources = new List <IConfiguredTemplateSource> {
realSource
};
}
searchSources = ConfiguredTemplateSourceHelper.Scan(searchSources, Program.Broker.ComponentRegistry.OfType <ITemplateSource>());
string aliasTemplateName = AliasRegistry.GetTemplateNameForAlias(templateName);
generator = null;
tmplt = null;
foreach (IGenerator gen in Program.Broker.ComponentRegistry.OfType <IGenerator>())
{
foreach (IConfiguredTemplateSource target in searchSources)
{
if (gen.TryGetTemplateFromSource(target, templateName, out tmplt))
{
generator = gen;
break;
}
if (aliasTemplateName != null && gen.TryGetTemplateFromSource(target, aliasTemplateName, out tmplt))
{
generator = gen;
break;
}
}
if (generator != null)
{
break;
}
}
if (generator == null || tmplt == null)
{
List <ITemplate> results = List(templateName, source).ToList();
if (results.Count == 0)
{
if (!string.IsNullOrWhiteSpace(templateName) || source.HasValue())
{
Reporter.Error.WriteLine($"No template containing \"{templateName}\" was found in any of the configured sources.".Bold().Red());
}
else
{
TableFormatter.Print(results, "(No Items)", " ", '-', new Dictionary <string, Func <ITemplate, string> >
{
{ "#", x => "0." },
{ "Templates", x => x.Name },
{ "Short Names", x => $"[{x.ShortName}]" }
});
}
return(false);
}
int index;
if (results.Count != 1 || string.IsNullOrWhiteSpace(templateName))
{
int counter = 0;
TableFormatter.Print(results, "(No Items)", " ", '-', new Dictionary <string, Func <ITemplate, string> >
{
{ "#", x => $"{++counter}." },
{ "Templates", x => x.Name },
{ "Short Names", x => $"[{x.ShortName}]" }
});
Reporter.Output.WriteLine();
Reporter.Output.WriteLine("Select a template [1]:");
string key = Console.ReadLine();
if (string.IsNullOrWhiteSpace(key))
{
key = "1";
}
while (!int.TryParse(key, out index))
{
if (string.Equals(key, "q", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
key = Console.ReadLine();
}
}
else
{
if (!quiet)
{
Reporter.Output.WriteLine($"Using template: {results[0].Name} [{results[0].ShortName}] {AliasRegistry.GetAliasForTemplate(results[0])}");
}
index = 1;
}
tmplt = results[index - 1];
generator = results[index - 1].Generator;
}
return(true);
}
