public static Type GetType(this TypeResolver typeResolver, TypeInfoData typeInfoData)
{
if (typeInfoData != null && typeInfoData.Name != null)
{
return(typeResolver.GetType(typeInfoData.Name));
}
return(null);
}
internal void InspectCompiledType(ProgramArgs prgArgs, TypeInfoData typeInfoData)
{
_typeInfoData = typeInfoData;
foreach (var t in typeInfoData.Assembly.GetExportedTypes())
{
if (!t.Name.Equals(prgArgs.TypeName))
{
continue;
}
typeInfoData.InspectedType = t;
break;
}
if (typeInfoData.InspectedType == null)
{
_typeInfoData.Logger.LogIt(LogSeverity.Fatal, "i18n::Cannot load/find type {0}", prgArgs.TypeName);
throw new TypeLoadException(prgArgs.TypeName);
}
typeInfoData.Namespace = typeInfoData.InspectedType.Namespace;
var ns = typeInfoData.InspectedType.GetCustomAttribute <AvroNamespaceAttribute>()?.NamespaceValue;
if (!string.IsNullOrWhiteSpace(ns))
{
typeInfoData.Namespace = ns;
}
var doc = typeInfoData.InspectedType.GetCustomAttribute <AvroDocAttribute>()?.DocValue;
if (!string.IsNullOrWhiteSpace(doc))
{
typeInfoData.DocValue = doc;
}
foreach (var field in typeInfoData.InspectedType.GetFields())
{
if (field.IsInitOnly || field.IsLiteral || field.IsStatic)
{
continue;
}
var efi = new ExtendedFieldInfo(field);
typeInfoData.FieldList.Add(efi);
_fieldInspector.Inspect(typeInfoData.Logger, efi);
if (efi.AvroType == AvroFieldType.Record || efi.AvroType == AvroFieldType.ArrayWithRecordType || efi.AvroType == AvroFieldType.MapWithRecordType)
{
AddSubFields(efi);
}
}
}
internal void InspectFileBasedCompiledType(ProgramArgs prgArgs, TypeInfoData typeInfoData)
{
_typeInfoData = typeInfoData;
if (!File.Exists(prgArgs.AssemblyName))
{
throw new FileNotFoundException(prgArgs.AssemblyName);
}
typeInfoData.FullAssemblyPath = Path.GetFullPath(prgArgs.AssemblyName);
typeInfoData.Assembly = Assembly.LoadFile(typeInfoData.FullAssemblyPath);
InspectCompiledType(prgArgs, typeInfoData);
}
internal void Read(TypeInfoData typeInfoData)
{
typeInfoData.IndentFactor = 2;
var configFileName = Assembly.GetEntryAssembly().Location + ".config";
if (!File.Exists(configFileName))
{
return;
}
typeInfoData.Logger.LogIt(LogSeverity.Verbose, "i18n::Reading config from " + configFileName);
foreach (var key in ConfigurationManager.AppSettings.AllKeys)
{
if (key.StartsWith("MetadataReference::Load", StringComparison.InvariantCultureIgnoreCase))
{
var v = ConfigurationManager.AppSettings.Get(key);
if (string.IsNullOrWhiteSpace(v))
{
continue;
}
typeInfoData.MetadataReferenceList.Add(MetadataReference.CreateFromFile(v));
}
if (string.Compare(key, "IndentFactor", StringComparison.InvariantCultureIgnoreCase) == 0)
{
var v = ConfigurationManager.AppSettings.Get(key);
typeInfoData.IndentFactor = int.TryParse(v, out var result) ? result : 2;
}
if (string.Compare(key, "I18N", StringComparison.CurrentCultureIgnoreCase) == 0)
{
typeInfoData.Logger.Locale = ConfigurationManager.AppSettings.Get(key);
}
}
foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
{
if (a.FullName.Contains("netstandard", StringComparison.InvariantCultureIgnoreCase))
{
typeInfoData.MetadataReferenceList.Add(MetadataReference.CreateFromFile(a.Location));
}
}
}
public void Compile(ProgramArgs prgArgs, TypeInfoData typeInfoData)
{
_logger = typeInfoData.Logger;
_usingList.Clear();
_fileNameList.Clear();
var sourceCode = LoadSourceCode(prgArgs.File);
var u = _usingList.Distinct().Aggregate((i, j) => i + Environment.NewLine + j);
sourceCode = u + Environment.NewLine + sourceCode;
using (var peStream = new MemoryStream())
{
var result = GenerateCode(sourceCode, typeInfoData.MetadataReferenceList).Emit(peStream);
if (!result.Success)
{
var failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error);
foreach (var diagnostic in failures)
{
_logger.LogIt(LogSeverity.Error, "{0}: {1} at {2}", diagnostic.Id, diagnostic.GetMessage(), diagnostic.Location);
}
_logger.LogIt(LogSeverity.Fatal, "i18n::Compilation failed");
throw new Exception("Compilation failed");
}
_logger.LogIt(LogSeverity.Info, "i18n::Compilation done without any error.");
peStream.Seek(0, SeekOrigin.Begin);
typeInfoData.Assembly = Assembly.Load(peStream.ToArray());
}
}
public int Run(ProgramArgs prgArgs)
{
var logger = new I18NLogger(prgArgs);
var typeInfoData = new TypeInfoData(logger);
new ConfigReader().Read(typeInfoData);
var ti = new TypeInspector();
if (!(string.IsNullOrWhiteSpace(prgArgs.AssemblyName) || string.IsNullOrWhiteSpace(prgArgs.TypeName)))
{
try
{
ti.InspectFileBasedCompiledType(prgArgs, typeInfoData);
}
catch (Exception ex)
{
logger.LogIt(LogSeverity.Fatal, ex.Message);
return((int)ReturnCode.TypeInspectionFailed);
}
}
else
{
if (!string.IsNullOrWhiteSpace(prgArgs.File))
{
try
{
new TypeCompiler().Compile(prgArgs, typeInfoData);
}
catch (Exception ex)
{
logger.LogIt(LogSeverity.Fatal, ex.Message);
return((int)ReturnCode.TypeCompilationFailed);
}
try
{
ti.InspectCompiledType(prgArgs, typeInfoData);
}
catch (Exception ex)
{
logger.LogIt(LogSeverity.Fatal, ex.Message);
return((int)ReturnCode.TypeInspectionFailed);
}
}
else
{
logger.LogIt(LogSeverity.Info, "i18n::NothingToDo");
return((int)ReturnCode.NothingToDo);
}
}
try
{
new AvroSchemaGenerator().Generate(prgArgs, typeInfoData);
}
catch (Exception ex)
{
logger.LogIt(LogSeverity.Fatal, ex.Message);
logger.LogIt(LogSeverity.Fatal, "i18n::Schema generation failed" + Environment.NewLine);
return((int)ReturnCode.SchemaGenerationFailed);
}
logger.LogIt(LogSeverity.Info, "i18n::Done - all is fine!");
return((int)ReturnCode.Ok);
}
internal void Generate(ProgramArgs prgArgs, TypeInfoData typeInfoData)
{
_prgArgs = prgArgs;
_indentProvider = new IndentProvider(" ", typeInfoData.IndentFactor);
_indentProvider.Prepare(20);
_indentProvider.IncLevel();
if (!_prgArgs.FlattenDirStructure)
{
var splitted = Path.Combine(typeInfoData.Namespace.Split('.', StringSplitOptions.RemoveEmptyEntries));
_prgArgs.OutDir = Path.GetFullPath(Path.Combine(prgArgs.OutDir, splitted));
}
else
{
_prgArgs.OutDir = Path.GetFullPath(prgArgs.OutDir);
}
if (!Directory.Exists(prgArgs.OutDir))
{
Directory.CreateDirectory(prgArgs.OutDir);
}
_sb.Clear();
_generatedTypes.Clear();
_sb.AppendLine("{");
_sb.Append(CreateCommonHeader());
if (typeInfoData.DocValue != null)
{
_sb.Append(_indentProvider.Get());
_sb.Append("doc".ToDoubleQoutedString());
_sb.Append(": ");
_sb.Append(typeInfoData.DocValue.ToDoubleQoutedString());
}
_sb.AppendLine(", ");
_sb.Append(_indentProvider.Get());
_sb.Append("name".ToDoubleQoutedString());
_sb.Append(": ");
_sb.Append(typeInfoData.InspectedType.Name.ToDoubleQoutedString());
_sb.AppendLine(", ");
_sb.Append(_indentProvider.Get());
_sb.Append("type".ToDoubleQoutedString());
_sb.Append(": ");
_sb.Append("record".ToDoubleQoutedString());
_sb.AppendLine(", ");
_sb.Append(_indentProvider.Get());
_sb.Append("namespace".ToDoubleQoutedString());
_sb.Append(": ");
_sb.Append(prgArgs.NamespaceToLowercase
? typeInfoData.Namespace.ToLowerInvariant().ToDoubleQoutedString()
: typeInfoData.Namespace.ToDoubleQoutedString());
_sb.AppendLine(", ");
WriteRecord(typeInfoData.FieldList);
_sb.AppendLine("}");
WriteAvroFile();
}
