/// <summary> /// User has requested the generation of code given an assembly and specification file. /// </summary> /// <param name="specification"></param> /// <param name="assembly"></param> /// <param name="outputPath"></param> public static void GenerateCode(FileInfo specification, FileInfo assembly, string outputPath = default) { if (specification == null) { throw new ArgumentException(Resources.NoSpecificationFileProvided, nameof(specification)); } // register the appropriate style class for its related type key. Each type in the specification needs to have a 'style' specified // for it to be able to generate the appropriate type of code for it. TypeGeneratorStore.Instance.Register(global::Birch.Generator.Styles.Extension.Style.Type, () => new global::Birch.Generator.Styles.Extension.Style()); TypeGeneratorStore.Instance.Register(global::Birch.Generator.Styles.Class.Style.Type, () => new global::Birch.Generator.Styles.Class.Style()); var job = JobReader.FromFile(Path.Join(specification.DirectoryName, specification.Name)); var outputTypeStore = OutputTypesStore.Create(job.Configuration.OutputTypes); var typeStore = new TypeStore(); typeStore.Load(Path.Join(assembly.DirectoryName, assembly.Name)); var modelBuilder = new ModelBuilder(typeStore, outputTypeStore); var models = modelBuilder.Create(job); var codeBuilder = new CodeBuilder(job); var output = codeBuilder.Create(models); if (outputPath != null) { File.WriteAllText(outputPath, output); Console.WriteLine(Resources.CodeWrittenTo, outputPath); } else { Console.WriteLine(output); } }
/// <summary> /// User has requested the generation of a specification file for an assembly. /// </summary> /// <param name="assembly"></param> /// <param name="outputPath"></param> /// <param name="typeFilter"></param> /// <param name="methodFilter"></param> /// <param name="templatesStyle"></param> /// <param name="templateExportStyle"></param> public static void GenerateSpecification(FileInfo assembly, string outputPath = default, string typeFilter = default, string methodFilter = default, string templatesStyle = default, TemplateExportStyle templateExportStyle = TemplateExportStyle.Embed) { var typeStore = new TypeStore(); typeStore.Load(Path.Join(assembly.DirectoryName, assembly.Name)); var g = new global::Birch.Generator.Specification.Generator(Path.Join(Directory.GetCurrentDirectory(), "\\Templates")); Func <ITypeDefinition, bool> typeFilterFunc; // lets see if we can convert the type filter into something that can be used at runtime... if (!string.IsNullOrEmpty(typeFilter)) { try { var parameter = System.Linq.Expressions.Expression.Parameter(typeof(ITypeDefinition), "typeDefinition"); var expression = DynamicExpressionParser.ParseLambda(new[] { parameter }, null, typeFilter); var compiled = expression.Compile(); typeFilterFunc = (typeDefinition) => (bool)compiled.DynamicInvoke(typeDefinition); } catch (Exception exception) { throw new ArgumentException($"Unable to parse type filter:'{typeFilter}'", exception); } } else { // just pull in everything typeFilterFunc = (s) => true; } Func <IMethod, bool> methodFilterFunc; if (!string.IsNullOrEmpty(methodFilter)) { try { var parameter = System.Linq.Expressions.Expression.Parameter(typeof(IMethod), "method"); var expression = DynamicExpressionParser.ParseLambda(new[] { parameter }, null, methodFilter); var compiled = expression.Compile(); methodFilterFunc = (typeDefinition) => (bool)compiled.DynamicInvoke(typeDefinition); } catch (Exception exception) { throw new ArgumentException($"Unable to method filter:'{methodFilter}'", exception); } } else { // just pull in everything methodFilterFunc = (s) => true; } var r = g.Generate(typeStore, typeFilterFunc, methodFilterFunc, templatesStyle); // if the user specified they want their templates to be individually saved, then we need to do that as well... if (templateExportStyle == TemplateExportStyle.File) { var outputDirectory = Path.GetDirectoryName(outputPath); var revisedTemplates = new List <Template>(); foreach (var template in r.Configuration.Templates) { var fileName = $"{template.Name}.{TemplateExtension}"; var fullPath = Path.Join(outputDirectory, fileName); File.WriteAllText(fullPath, template.Content); revisedTemplates.Add(new Template(template.Name, template.Type, TemplateLocation.File) { Path = fileName }); } r.Configuration.Templates = revisedTemplates; } var f = new JsonFormatter(); var output = f.Format(r); if (outputPath != null) { File.WriteAllText(outputPath, output); Console.WriteLine(Resources.SpecificationFileWritten, outputPath); } else { Console.WriteLine(output); } }