public void Reset(string compilerPath) { CompilerPath = compilerPath; oldPocoLibrary = PocoLibrary.Clone(); oldClientLibrary = ClientLibrary.Clone(); oldPortableLibrary = PortableLibrary.Clone(); oldPhpSource = PhpSource.Clone(); oldWpfLibrary = WpfLibrary.Clone(); oldPostgresLibrary = PostgresLibrary.Clone(); oldOracleLibrary = OracleLibrary.Clone(); }
public CompileTargets() { PocoLibrary = new LibraryInfo("Poco", "dotnet_poco", PocoDependencies); ClientLibrary = new LibraryInfo("Client", "dotnet_client", PocoDependencies); PortableLibrary = new LibraryInfo("Portable", "dotnet_portable", new string[0]); PhpSource = new LibraryInfo("Php", "php_client", new string[0], true, ".php"); WpfLibrary = new LibraryInfo("Wpf", "wpf", WpfDependencies); PostgresLibrary = new LibraryInfo("Postgres", "dotnet_server_postgres", RevenjDependencies); OracleLibrary = new LibraryInfo("Oracle", "dotnet_server_oracle", RevenjDependencies); Targets = new[] { PocoLibrary, ClientLibrary, PortableLibrary, PhpSource, WpfLibrary, PostgresLibrary, OracleLibrary }; }
private void Compile(LibraryInfo info, Dictionary <string, string> files, bool filter) { if (!info.Compile) { return; } var references = info.References .Concat(Directory.GetFiles(info.DependenciesPath, "*.dll")) .Except(new[] { Path.Combine(info.DependenciesPath, info.Name + ".dll") }); var sources = files.Select(it => it.Value).ToArray(); var target = Path.Combine(info.TargetPath, info.Name + ".dll"); var assembly = Compiler.GenerateAssembly(target, sources, references); }
private void CopySource(LibraryInfo info, Dictionary <string, string> files, bool filter) { if (!info.Compile) { return; } var sources = (from f in files let name = filter ? f.Key.Substring(1) : f.Key + info.Extension select new { Key = name, f.Value }) .ToDictionary(it => it.Key, it => it.Value); DumpToDisk(info.TargetPath, sources, 3); }
private void ReadInfo(LibraryInfo info, IPropertyBag pBag) { info.CompileOption = TryReadBool(info.Type + ".Compile", pBag); if (!info.SourceOnly) { info.Name = TryReadString(info.Type + ".Name", pBag) ?? info.Name; } info.Target = TryReadString(info.Type + ".Target", pBag) ?? info.Target; info.Dependencies = TryReadString(info.Type + ".Dependencies", pBag) ?? info.Dependencies; info.Namespace = TryReadString(info.Type + ".Namespace", pBag) ?? info.Namespace; info.WithActiveRecord = TryReadBool(info.Type + ".ActiveRecord", pBag, info.WithActiveRecord); info.WithHelperMethods = TryReadBool(info.Type + ".HelperMethods", pBag, info.WithHelperMethods); info.WithManualJson = TryReadBool(info.Type + ".WithManualJson", pBag, info.WithManualJson); info.UseUtc = TryReadBool(info.Type + ".UseUtc", pBag, info.UseUtc); info.Legacy = TryReadBool(info.Type + ".Legacy", pBag, info.Legacy); info.MinimalSerialization = TryReadBool(info.Type + ".MinimalSerialization", pBag, info.MinimalSerialization); info.NoPrepareExecute = TryReadBool(info.Type + ".NoPrepareExecute", pBag, info.NoPrepareExecute); }
private Either <Dictionary <string, string> > RunCompiler(string dslCompiler, LibraryInfo target, List <string> dsls) { var sb = new StringBuilder(); sb.Append("target=").Append(target.CompilerName); if (target.WithActiveRecord) { sb.Append(" settings=active-record"); } if (!target.WithHelperMethods) { sb.Append(" settings=no-helpers"); } if (target.WithManualJson) { sb.Append(" settings=manual-json"); } if (target.UseUtc) { sb.Append(" settings=utc"); } if (target.MinimalSerialization) { sb.Append(" settings=minimal-serialization"); } if (target.NoPrepareExecute) { sb.Append(" settings=no-prepare-execute"); } if (target.Legacy) { sb.Append(" settings=legacy"); } sb.Append(" format=xml"); var result = Compiler.CompileDsl(sb, dsls, null, cms => XElement.Load(cms)); if (result.Success) { var dict = (from x in result.Value.Elements() let elem = x.Elements() select new { key = elem.First().Value, value = elem.Last().Value }) .ToDictionary(it => it.key, it => it.value); return(Either.Success(dict)); } else { return(Either <Dictionary <string, string> > .Fail(result.Error)); } }
private void WriteInfo(LibraryInfo info, IPropertyBag pBag) { var reference = new LibraryInfo(info.Type, null, null); object val; if (reference.CompileOption != info.CompileOption) { val = info.CompileOption.ToString(); pBag.Write(info.Type + ".Compile", ref val); } if (reference.Name != info.Name) { val = info.Name; pBag.Write(info.Type + ".Name", ref val); } if (reference.Target != info.Target) { val = info.Target; pBag.Write(info.Type + ".Target", ref val); } if (reference.Dependencies != info.Dependencies) { val = info.Dependencies; pBag.Write(info.Type + ".Dependencies", ref val); } if (reference.Namespace != info.Namespace) { val = info.Namespace; pBag.Write(info.Type + ".Namespace", ref val); } if (reference.WithActiveRecord != info.WithActiveRecord) { val = info.WithActiveRecord.ToString(); pBag.Write(info.Type + ".ActiveRecord", ref val); } if (reference.WithHelperMethods != info.WithHelperMethods) { val = info.WithHelperMethods.ToString(); pBag.Write(info.Type + ".HelperMethods", ref val); } if (reference.WithManualJson != info.WithManualJson) { val = info.WithManualJson.ToString(); pBag.Write(info.Type + ".WithManualJson", ref val); } if (reference.UseUtc != info.UseUtc) { val = info.UseUtc.ToString(); pBag.Write(info.Type + ".UseUtc", ref val); } if (reference.Legacy != info.Legacy) { val = info.Legacy.ToString(); pBag.Write(info.Type + ".Legacy", ref val); } if (reference.MinimalSerialization != info.MinimalSerialization) { val = info.MinimalSerialization.ToString(); pBag.Write(info.Type + ".MinimalSerialization", ref val); } if (reference.NoPrepareExecute != info.NoPrepareExecute) { val = info.NoPrepareExecute.ToString(); pBag.Write(info.Type + ".NoPrepareExecute", ref val); } }