public override IDictionary <string, string> GenerateCode(CommandDefinition commandDefinition, CodeGeneratorContext context) { var result = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); if (String.IsNullOrWhiteSpace(Settings.DefinitionTemplates.CommandTemplate.TemplatePath)) { return(result); } var commandGenerator = TemplatesManager.GetGeneratorForTemplate(Settings.DefinitionTemplates.CommandTemplate); var className = commandDefinition.Name.Dehumanize(); string codeResult = commandGenerator(new { command = commandDefinition, className = className, domain = context.Domain, rootNamespace = Settings.RootNamespace, context = context }); var outputPath = Utility.ReplaceTokensInPath(Settings.DefinitionTemplates.CommandTemplate.OutputPath, className, context, Settings); result.Add(outputPath, codeResult); return(result); }
public override IDictionary <string, string> GenerateCode(DomainDefinition domainDefinition, CodeGeneratorContext context) { var result = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); var typeGenerator = ServiceProvider.GetRequiredService <ICodeGenerator <TypeDefinition> >(); foreach (var type in domainDefinition.Types) { typeGenerator.GenerateCode(type, context) .ToList() .ForEach(x => result.Add(x.Key, x.Value)); } var eventGenerator = ServiceProvider.GetRequiredService <ICodeGenerator <EventDefinition> >(); foreach (var @event in domainDefinition.Events) { eventGenerator.GenerateCode(@event, context) .ToList() .ForEach(x => result.Add(x.Key, x.Value)); } var commandGenerator = ServiceProvider.GetRequiredService <ICodeGenerator <CommandDefinition> >(); foreach (var command in domainDefinition.Commands) { commandGenerator.GenerateCode(command, context) .ToList() .ForEach(x => result.Add(x.Key, x.Value)); } if (String.IsNullOrWhiteSpace(Settings.DefinitionTemplates.DomainTemplate.TemplatePath)) { return(result); } var domainGenerator = TemplatesManager.GetGeneratorForTemplate(Settings.DefinitionTemplates.DomainTemplate); var className = domainDefinition.Name.Dehumanize(); string codeResult = domainGenerator(new { domain = domainDefinition, className = className, rootNamespace = Settings.RootNamespace, context = context }); var outputPath = Utility.ReplaceTokensInPath(Settings.DefinitionTemplates.DomainTemplate.OutputPath, className, context, Settings); result.Add(outputPath, codeResult); return(result); }
public override IDictionary <string, string> GenerateCode(TypeDefinition typeDefinition, CodeGeneratorContext context) { var result = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); if (context.KnownTypes == null) { throw new InvalidOperationException("Expected knowntypes to be specified in context"); } if (context.Domain == null) { throw new InvalidOperationException("Expected domain to be specified in context"); } var typeInfo = context.KnownTypes[$"{context.Domain.Name}.{typeDefinition.Id}"]; if (typeInfo.IsPrimitive) { return(result); } //Base the code generation template on the specified type definition type. CodeGenerationTemplateSettings templateSettings; switch (typeDefinition.Type) { case "object": templateSettings = Settings.DefinitionTemplates.TypeObjectTemplate; break; case "string": templateSettings = Settings.DefinitionTemplates.TypeEnumTemplate; break; default: throw new InvalidOperationException($"Unsupported Type Definition Type: {typeDefinition.Type}"); } // Special override for the headers object to be an open object. // TODO: make this kind of override configurable. if (context.Domain.Name == "Network" && typeDefinition.Id == "Headers") { templateSettings = Settings.DefinitionTemplates.TypeHashTemplate; } if (String.IsNullOrWhiteSpace(templateSettings.TemplatePath)) { return(result); } var typeGenerator = TemplatesManager.GetGeneratorForTemplate(templateSettings); var className = typeDefinition.Id.Dehumanize(); var codeResult = typeGenerator(new { type = typeDefinition, className = className, domain = context.Domain, rootNamespace = Settings.RootNamespace, context = context }); var outputPath = Utility.ReplaceTokensInPath(templateSettings.OutputPath, className, context, Settings); result.Add(outputPath, codeResult); return(result); }
public override IDictionary <string, string> GenerateCode(ProtocolDefinition protocolDefinition, CodeGeneratorContext context) { if (String.IsNullOrWhiteSpace(Settings.TemplatesPath)) { Settings.TemplatesPath = Path.GetDirectoryName(Settings.TemplatesPath); } ICollection <DomainDefinition> domains; if (Settings.IncludeDeprecatedDomains) { domains = protocolDefinition.Domains; } else { domains = protocolDefinition.Domains .Where(d => d.Deprecated == false) .ToList(); } //Get commandinfos as an array. ICollection <CommandInfo> commands = new List <CommandInfo>(); foreach (var domain in domains) { foreach (var command in domain.Commands) { commands.Add(new CommandInfo { CommandName = $"{domain.Name}.{command.Name}", FullTypeName = $"{domain.Name.Dehumanize()}.{command.Name.Dehumanize()}Command", FullResponseTypeName = $"{domain.Name.Dehumanize()}.{command.Name.Dehumanize()}CommandResponse" }); } } //Get eventinfos as an array ICollection <EventInfo> events = new List <EventInfo>(); foreach (var domain in domains) { foreach (var @event in domain.Events) { events.Add(new EventInfo { EventName = $"{domain.Name}.{@event.Name}", FullTypeName = $"{domain.Name.Dehumanize()}.{@event.Name.Dehumanize()}Event" }); } } //Get typeinfos as a dictionary. var types = GetTypesInDomain(domains); //Create an object that contains information that include templates can use. var includeData = new { chromeVersion = protocolDefinition.ChromeVersion, runtimeVersion = Settings.RuntimeVersion, rootNamespace = Settings.RootNamespace, domains = domains, commands = commands, events = events, types = types.Select(kvp => kvp.Value).ToList() }; var result = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); //Generate include files from templates. foreach (var include in Settings.Include) { var includeCodeGenerator = TemplatesManager.GetGeneratorForTemplate(include); var includeCodeResult = includeCodeGenerator(includeData); result.Add(include.OutputPath, includeCodeResult); } //Generate code for each domain, type, command, event from their respective templates. GenerateCode(domains, types) .ToList() .ForEach(x => result.Add(x.Key, x.Value)); return(result); }