public async Task GenerateAsync()
{
var provider = introspectionProviders.Single(x => x.SchemaType == settings.Schema.SchemaType());
var schema = await provider.LoadSchema(settings.Schema);
// we need to load in the scheme
var sources = new List <NamedSource>();
sources.Add(new NamedSource()
{
Path = settings.Schema.Location, Body = schema
});
foreach (var s in settings.SourcePaths)
{
sources.Add(new NamedSource()
{
Path = s, Body = File.ReadAllText(s)
});
}
// we want to track the file that the operation is loaded from
// lets make a locatino index look up table and provide it
var doc = Parse(sources);
var model = new Models.ViewModel(doc, settings);
var fileResult = new TemplateEngine(settings.Templates).Generate(model);
Directory.CreateDirectory(Path.GetDirectoryName(settings.OutputPath));
File.WriteAllText(settings.OutputPath, fileResult);
}
internal void Parse()
{
Document = IntrospectedSchemeParser.Parse(Sources, this.settings);
if (Document.Errors.Any())
{
foreach (var error in Document.Errors)
{
logger.Error(error.ToString());
}
HasParsingErrors = true;
return;
}
Model = new Models.ViewModel(Document, this.settings);
HasParsingErrors = false;
}
public TemplateEngine(IEnumerable <string> templates, IDictionary <string, string> templateArguments, ILogger logger, Models.ViewModel model)
{
this.logger = logger;
this.model = model;
this.engine = HandlebarsDotNet.Handlebars.Create(new HandlebarsConfiguration
{
ThrowOnUnresolvedBindingExpression = true,
});
this.engine.RegisterHelper("concat", (writer, context, args) =>
{
writer.WriteSafeString(string.Concat(args));
});
this.engine.RegisterHelper("pascalCase", (writer, context, args) =>
{
writer.WriteSafeString(args[0].ToString().ToPascalCase());
});
this.engine.RegisterHelper("camelCase", (writer, context, args) =>
{
writer.WriteSafeString(args[0].ToString().ToCamelCase());
});
this.engine.RegisterHelper("replace", (writer, context, args) =>
{
string toReplace = args[1].ToString();
string toReplaceWith = args[2].ToString();
writer.WriteSafeString(args[0].ToString().Replace(toReplace, toReplaceWith));
});
this.engine.RegisterHelper("resolve", (writer, context, args) =>
{
string target = args[0].ToString();
var currentDirectory = Path.GetDirectoryName(model.OutputPath);
System.Uri uri1;
if (target.StartsWith("~/"))
{
uri1 = new Uri(Path.GetFullPath(Path.Combine(model.RootPath, target.Substring(2))));
}
else
{
uri1 = new Uri(target, UriKind.Relative);
}
System.Uri uri2 = new Uri(currentDirectory.TrimEnd() + "\\");
Uri relativeUri = uri2.MakeRelativeUri(uri1);
var path = relativeUri.ToString();
if (path[0] != '.')
{
path = "./" + path;
}
writer.WriteSafeString(path);
});
HandlebarsBlockHelper ifTemplateHelper = (output, options, context, args) =>
{
var val = this.engine.Compile("{{> " + args[0].ToString() + "}}")((object)context)?.ToString()?.Trim();
var isSet = !string.IsNullOrWhiteSpace(val);
if (args.Length > 1)
{
isSet = val.Equals(args[1]?.ToString());
}
if (isSet)
{
options.Template(output, context);
}
else
{
options.Inverse(output, context);
}
};
this.engine.RegisterHelper("ifTemplate", ifTemplateHelper);
//this.engine.RegisterHelper("ifTemplateSet", (writer, context, args) =>
//{
// var val = this.engine.Compile("{{> " + args[0].ToString() + "}}")(context);
// writer.WriteSafeString(string.IsNullOrWhiteSpace(val) ? "" : args[1]);
//});
this.engine.Configuration.TextEncoder = new NullEncoder();
//engine.RegisterHelper("render", (w, c, a) =>
//{
// if (c is Models.TypeViewModel typeVm)
// {
// // this is the typerefcontext
// w.WriteSafeString("Type");
// return;
// }
// if (c is Models.TypeReferenceModel typeRef)
// {
// // this is the typerefcontext
// w.WriteSafeString("TypeReference_" + typeRef.ScalerType.ToString());
// return;
// }
//});
foreach (string templatePath in templates)
{
string templateContents = LoadTemplate(templatePath);
ProcessTemplate(templateContents);
}
foreach (var a in templateArguments)
{
this.engine.RegisterTemplate(a.Key, a.Value);
}
}
