public string GenerateFile(IFileMetaData fileMetaData, IGeneratorConfiguration config)
{
var classDeclaration = GeneratClassSyntax(fileMetaData, config);
if (config.MapMethod)
{
var staticMethodSyntax = config.TermAttribute == TermAttributeType.none ?
MapMethodGenerator.MapStaticInstanceMethodSyntax(fileMetaData, config)
: MapMethodGenerator.MapStaticInstanceMethodSyntax(classDeclaration);
classDeclaration = classDeclaration.AddMembers(staticMethodSyntax);
}
if (string.IsNullOrEmpty(config.Namespace))
{
var usings = new SyntaxList <UsingDirectiveSyntax>();
foreach (var usingNamespace in config.Usings)
{
usings = usings.Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(usingNamespace)));
}
var node = SyntaxFactory.CompilationUnit()
.WithUsings(usings)
.WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(classDeclaration));
return(FormatDeclarationSyntax(node));
}
var @namespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(config.Namespace));
foreach (var usingNamespace in config.Usings)
{
@namespace = @namespace.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(usingNamespace)));
}
@namespace = @namespace.AddMembers(classDeclaration);
return(FormatDeclarationSyntax(@namespace));
}
public string RenameFile(IFileMetaData FileName, int Position, NameExtensionHelper Helper)
{
Helper.Text = FileName.Name;
string numberString;
int num = Position + _start;
// Format the position number into the correct format
switch (_numberFormat)
{
case NumberingFormat.LowercaseLetters:
numberString = StringNumberConversions.NumberToString(num);
break;
case NumberingFormat.OneZero:
numberString = InsertZeros(num, 1);
break;
case NumberingFormat.TwoZeros:
numberString = InsertZeros(num, 2);
break;
case NumberingFormat.ThreeZeros:
numberString = InsertZeros(num, 3);
break;
case NumberingFormat.NoZeros:
goto default;
default:
numberString = num.ToString();
break;
}
// This function determines the text format, we will pass it to modify in the NameExtensionHelper
Func <String, String> _textFormatFn;
switch (_textFormat)
{
case NumberingTextFormat.NumberText:
_textFormatFn = (OldName) => numberString + _text;
break;
case NumberingTextFormat.NumberTextOldName:
_textFormatFn = (OldName) => numberString + _text + OldName;
break;
case NumberingTextFormat.OldNameTextNumber:
_textFormatFn = (OldName) => OldName + _text + numberString;
break;
case NumberingTextFormat.TextNumber:
goto default;
default:
_textFormatFn = (OldName) => _text + numberString;
break;
}
return(Helper.Modify(_textFormatFn));
}
private CodeTypeDeclaration CreateClass(string fileName, IFileMetaData fileMetaData)
{
var classType = new CodeTypeDeclaration(CodeDomUtils.ExtractClassName(fileName, capitalize) + "Type")
{
IsClass = true
};
CodeConstructor constructor = new CodeConstructor()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
constructor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IRow), "row"));
constructor.Statements.Add(new CodeSnippetExpression("this.row = row"));
classType.Members.Add(constructor);
var row = new CodeMemberField()
{
Type = new CodeTypeReference(typeof(IRow)),
Attributes = MemberAttributes.Private | MemberAttributes.Final,
Name = "row",
};
classType.Members.Add(row);
usedNames.Clear();
foreach (var field in fileMetaData.Fields)
{
classType.Members.Add(CreateProperty(field));
}
return(classType);
}
private string AppendHeader(IOutputFile output)
{
string content = output.Content;
IFileMetaData fileMetaData = output.FileMetaData;
string header = GetHeader(output);
//Deal with XML Declartions <?xml...>
switch (fileMetaData.FileExtension.ToLower())
{
case "xml":
case "config":
if (content.Substring(0, 2) == "<?")
{
int pos = content.IndexOf(">\r\n");
return(content.Substring(0, pos + 3) + header + content.Substring(pos + 3));
}
break;
}
if (!string.IsNullOrWhiteSpace(header))
{
content = header + content;
}
return(content);
}
private ExplorerItem GetFileReaderItem(IFileMetaData fileMetaData, bool isCoreFile)
{
var explorerIcon = isCoreFile ? ExplorerIcon.View : ExplorerIcon.Table;
var explorerItem = new ExplorerItem(CodeDomUtils.ExtractClassName(fileMetaData.FileName, capitalize),
ExplorerItemKind.QueryableObject, explorerIcon)
{
Children = new List <ExplorerItem>(),
IsEnumerable = true
};
usedNames.Clear();
foreach (var field in fileMetaData.Fields)
{
var fieldName = CodeDomUtils.ModifyKeywords(field.Term, capitalize);
int i = 1;
while (usedNames.Contains(fieldName))
{
fieldName += i.ToString();
i++;
}
usedNames.Add(fieldName);
var icon = GetFieldIcon(fileMetaData, field);
var fieldItem = new ExplorerItem(fieldName, ExplorerItemKind.Property, icon);
explorerItem.Children.Add(fieldItem);
}
return(explorerItem);
}
public Tokenizer(IFileMetaData fileMetaData)
{
this.fileMetaData = fileMetaData ?? throw new ArgumentNullException(nameof(fileMetaData));
this.HasQuotes = fileMetaData.FieldsEnclosedBy.Length > 0;
this.Delimiter = fileMetaData.FieldsTerminatedBy.FirstOrDefault();
this.Quotes = fileMetaData.FieldsEnclosedBy.FirstOrDefault();
}
public void MoveNext()
{
IFileMetaData metaData = _contentManagement.MoveNext();
if (metaData != null)
{
if (tmp == metaData.ContentPath)
{
}
tmp = metaData.ContentPath;
MediaSource = metaData.ContentPath;
ErrorMessage = String.Empty;
}
else
{
ConfigurationProvider cp = new ConfigurationProvider();
IConfigSettings cs = cp.Load();
if (_demographics != null)
{
ErrorMessage = String.Format(@"Media Content is missing. Root Directory setting: {0}\{1}", cs.RootContentDirectory, _currentZone);
}
else
{
ErrorMessage = String.Format(@"Media Content is missing in the following directory: {0}\{1} for {2}yo {3}", cs.RootContentDirectory, _currentZone, _demographics.Age.ToString(), _demographics.Gender.ToString());
}
}
}
public virtual IFileReaderAggregate CreateFileReader(string fileName, IFileMetaData fileMetaData)
{
return(new FileReader(fileName,
CreateRowFactory(),
CreateTokenizer(fileMetaData),
fileMetaData,
configuration.GetOptions <FileReaderConfiguration>()));
}
private ExplorerIcon GetFieldIcon(IFileMetaData fileMetaData, FieldType field)
{
if (fileMetaData.Id.IndexSpecified && fileMetaData.Id.Index == field.Index)
{
return(ExplorerIcon.Key);
}
return(ExplorerIcon.Column);
}
public string GenerateClass(IFileMetaData fileMetaData, IGeneratorConfiguration config)
{
var classDeclaration = GeneratClassSyntax(fileMetaData, config);
var doc = Formatter.Format(classDeclaration, new AdhocWorkspace());
var code = doc.ToFullString();
return(code);
}
public string GenerateSource(string fileName, IFileMetaData fileMetaData)
{
var DwCArchive = CreateNamespace();
var classType = CreateClass(fileName, fileMetaData);
DwCArchive.Types.Add(classType);
return(CodeDomUtils.GenerateSourceFromCodeDom(DwCArchive));
}
public StreamReader(
IRowFactory rowFactory,
ITokenizer tokenizer,
IFileMetaData fileMetaData)
{
this.fileMetaData = fileMetaData;
this.rowFactory = rowFactory;
this.tokenizer = tokenizer;
}
public MetaDataFixture()
{
var metaDataReader = factory.CreateMetaDataReader();
var metaData = metaDataReader.ReadMetaData(path);
coreFileMetaData = factory.CreateCoreMetaData(metaData.Core);
extensionFileMetaData = metaData.Extension.ToList()
.Select(e => factory.CreateExtensionMetaData(e));
}
public void GenerateArchiveDbAssembly(IFileMetaData coreFileMetaData,
IEnumerable <IFileMetaData> extensionFileMetaData,
string assemblyName, string driverFolder)
{
var sources = GenerateSourceFiles(coreFileMetaData, extensionFileMetaData);
sources.Add(GenerateArchiveDb(coreFileMetaData, extensionFileMetaData));
RoslynCompile(sources.ToArray(), assemblyName, driverFolder);
}
private string GenerateArchiveDb(IFileMetaData coreFileMetaData,
IEnumerable <IFileMetaData> extensionFileMetaData)
{
var archiveDbCodeDom = new ArchiveDbCodeDom(capitalize, fileReaderConfig, rowFactoryConfig);
var archiveDbCs = archiveDbCodeDom.GenerateSource(coreFileMetaData, extensionFileMetaData);
Log(archiveDbCs);
return(archiveDbCs);
}
public void Setup()
{
IFileMetaData fileMetaData = abstractFactory.CreateCoreMetaData(new CoreFileType()
{
FieldsTerminatedBy = "\\t",
FieldsEnclosedBy = ""
});
tokenizer = abstractFactory.CreateTokenizer(fileMetaData);
}
public static string GetRelativeFilePathWithFileName(this IFileMetaData fm)
{
string relativePath = fm.GetRelativeFilePath();
if (!string.IsNullOrWhiteSpace(relativePath))
{
return($"{relativePath}\\{fm.FileNameWithExtension()}");
}
return(fm.FileNameWithExtension());
}
public string GenerateSource(IFileMetaData coreFileMetaData,
IEnumerable <IFileMetaData> extensionFileMetaData)
{
var DwCArchive = CreateNamespace();
var classType = CreateClass(coreFileMetaData, extensionFileMetaData);
DwCArchive.Types.Add(classType);
return(CodeDomUtils.GenerateSourceFromCodeDom(DwCArchive));
}
public static string GetRelativeFilePathWithFileName(this IFileMetaData fm)
{
var relativePath = fm.GetRelativeFilePath();
if (!string.IsNullOrWhiteSpace(relativePath))
{
return(Path.Combine(relativePath, fm.FileNameWithExtension()));
}
return(fm.FileNameWithExtension());
}
public FileReader(string fileName,
IRowFactory rowFactory,
ITokenizer tokenizer,
IFileMetaData fileMetaData,
FileReaderConfiguration config)
{
this.config = config;
this.FileName = fileName;
this.FileMetaData = fileMetaData;
FileReaderUtils.ValidateLineEnds(fileMetaData.LinesTerminatedBy);
streamReader = new StreamReader(rowFactory, tokenizer, fileMetaData);
}
public string RenameFile(IFileMetaData FileName, int Position, NameExtensionHelper Helper)
{
Helper.Text = FileName.Name;
if (_useRegex)
{
return(Helper.RegexReplace(_searchRegex, _replaceRegex, _caseSensitive));
}
else
{
return(Helper.Replace(_searchRegex, _replaceRegex, _caseSensitive));
}
}
public void ShouldReturnDefaultMetaDataOnNull(IFileMetaData fileMetaData)
{
Assert.Null(fileMetaData.FileName);
Assert.Empty(fileMetaData.Fields);
Assert.Equal(Encoding.UTF8, fileMetaData.Encoding);
Assert.Equal("YYYY-MM-DD", fileMetaData.DateFormat);
Assert.Equal("\"", fileMetaData.FieldsEnclosedBy);
Assert.Equal(",", fileMetaData.FieldsTerminatedBy);
Assert.Equal(0, fileMetaData.HeaderRowCount);
Assert.Equal("\n", fileMetaData.LinesTerminatedBy);
Assert.Equal(1, fileMetaData.LineTerminatorLength);
Assert.Equal(RowTypes.SimpleDarwinRecord, fileMetaData.RowType);
}
private CodeTypeDeclaration CreateClass(IFileMetaData coreFileMetaData,
IEnumerable <IFileMetaData> extensionFileMetaData)
{
var classType = new CodeTypeDeclaration("ArchiveDb")
{
IsClass = true,
};
classType.BaseTypes.Add(typeof(IDisposable));
CodeConstructor constructor = new CodeConstructor()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
constructor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "fileName"));
constructor.Statements.Add(new CodeSnippetExpression("this.archive = new ArchiveReader(fileName)"));
var configBuilder = new StringBuilder("var factory = new DefaultFactory(cfg => {\n");
if (fileReaderConfig != null)
{
configBuilder.Append($"cfg.Add<FileReaderConfiguration>(cfg => cfg.BufferSize = {fileReaderConfig.BufferSize});\n");
}
if (rowFactoryConfig != null)
{
configBuilder.Append($"cfg.Add<RowFactoryConfiguration>(cfg => cfg.Strategy = RowStrategy.{rowFactoryConfig.Strategy});\n");
}
configBuilder.Append("});");
if (fileReaderConfig != null || rowFactoryConfig != null)
{
constructor.Statements
.Add(new CodeSnippetExpression(configBuilder.ToString()));
}
classType.Members.Add(constructor);
var archive = new CodeMemberField()
{
Type = new CodeTypeReference(typeof(ArchiveReader)),
Attributes = MemberAttributes.Private | MemberAttributes.Final,
Name = "archive",
};
classType.Members.Add(archive);
classType.Members.Add(CreateCoreFileProperty(coreFileMetaData));
foreach (var extension in extensionFileMetaData)
{
classType.Members.Add(CreateExtensionFileProperty(extension));
}
classType.Members.Add(CreateDisposeMethod());
return(classType);
}
private CodeMemberProperty CreateExtensionFileProperty(IFileMetaData fileMetaData)
{
var propertyName = CodeDomUtils.ExtractClassName(fileMetaData.FileName, capitalize);
var propertyTypeName = propertyName + "Type";
var fieldProperty = new CodeMemberProperty()
{
Type = new CodeTypeReference($"IEnumerable<{propertyTypeName}>"),
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = propertyName,
HasGet = true
};
fieldProperty.GetStatements.Add(new CodeSnippetExpression($"return archive.Extensions.GetFileReaderByFileName(\"{fileMetaData.FileName}\").DataRows.Select( row => new {propertyTypeName}(row) )"));
return(fieldProperty);
}
public void Setup()
{
Random rand = new Random();
sequence = Enumerable.Range(0, fields.Length - 1)
.OrderBy(n => rand.Next())
.ToArray();
var metaData = FieldsMetaDataBuilder.Fields()
.AutomaticallyIndex()
.AddField(_ => _.Term("id"))
.AddField(_ => _.Term(Terms.taxonID))
.AddField(_ => _.Term(Terms.acceptedNameUsageID))
.AddField(_ => _.Term(Terms.parentNameUsageID))
.AddField(_ => _.Term(Terms.nameAccordingToID))
.AddField(_ => _.Term(Terms.scientificName))
.AddField(_ => _.Term(Terms.acceptedNameUsage))
.AddField(_ => _.Term(Terms.parentNameUsage))
.AddField(_ => _.Term(Terms.nameAccordingTo))
.AddField(_ => _.Term(Terms.higherClassification))
.AddField(_ => _.Term(Terms.@class))
.AddField(_ => _.Term(Terms.order))
.AddField(_ => _.Term(Terms.family))
.AddField(_ => _.Term(Terms.genus))
.AddField(_ => _.Term(Terms.subgenus))
.AddField(_ => _.Term(Terms.specificEpithet))
.AddField(_ => _.Term(Terms.infraspecificEpithet))
.AddField(_ => _.Term(Terms.taxonRank))
.AddField(_ => _.Term(Terms.scientificNameAuthorship))
.AddField(_ => _.Term(Terms.taxonomicStatus))
.AddField(_ => _.Term(Terms.modified))
.AddField(_ => _.Term(Terms.license))
.AddField(_ => _.Term(Terms.bibliographicCitation))
.AddField(_ => _.Term(Terms.references))
.Build();
var coreFileType = new CoreFileType();
foreach (var m in metaData)
{
coreFileType.Field.Add(m);
}
var defaultFactory = new DefaultFactory();
fileMetaData = defaultFactory.CreateCoreMetaData(coreFileType);
rowFactory = defaultFactory.CreateRowFactory();
}
public VisualStudio2015SolutionTemplate(IApplication application, SolutionFile existingSolution)
{
_application = application;
_fileMetaData = CreateMetaData();
Projects = _application.Projects;
ExistingSolution = existingSolution;
SolutionFolders = Projects.Where(x => x.SolutionFolder() != null && x.Folder.Id != application.Id)
.GroupBy(x => x.SolutionFolder())
.ToDictionary(x => x.Key, x => x.ToList())
.Select(x => new SolutionFolder(x.Key, x.Value))
.ToList();
foreach (var solutionFolder in SolutionFolders)
{
UpdateSolutionFolder(solutionFolder);
}
}
public string RenameFile(IFileMetaData FileName, int Position, NameExtensionHelper Helper)
{
Helper.Text = FileName.Name;
DateTime date;
switch (_dateType)
{
case DateTimeType.Current:
date = DateTime.Now;
break;
case DateTimeType.Created:
date = FileName.Created;
break;
case DateTimeType.Modified:
date = FileName.Modified;
break;
case DateTimeType.PhotoTaken:
if (FileName.EXIF == null)
{
date = FileName.Created;
}
else
{
date = FileName.EXIF.DateTaken;
}
break;
default:
date = DateTime.Now;
break;
}
string dateString;
try
{
dateString = String.Format("{0:" + _dateFormat + "}", date);
}
catch (FormatException)
{
dateString = "";
}
return(Helper.Insert(_position, _fromLeft, dateString));
}
/// <inheritdoc/>
public async Task <IFileMetaData> CreateAsync(string fileName, string fileType, Stream stream, bool throwOnException = true)
{
try
{
ValidateRules(_fileServiceConfig, stream, fileType, fileName);
IFileMetaData fileMetaData = await Task.Factory.StartNew(() => new FileMetaData(_fileServiceConfig, stream, fileName, fileType, false));
return(fileMetaData);
}
catch (Exception ex)
{
if (throwOnException)
{
throw ex;
}
return(null);
}
}
/// <summary>
/// Perform the renaming
/// </summary>
/// <param name="FileName">The name of the file</param>
/// <param name="Position">Position in the sequence (not used in this class)</param>
/// <returns>The new filename</returns>
public string RenameFile(IFileMetaData FileName, int Position, NameExtensionHelper Helper)
{
string newName;
Helper.Text = FileName.Name;
//NameExtensionHelper nameExtension = NameExtensionHelper.CreateNameExtensionHelper(FileName.Name, _behaviour);
if (InsertOrOverwrite)
{
newName = Helper.Insert(_position, FromLeft, Text);
}
else
{
newName = Helper.Overwrite(_position, FromLeft, Text);
}
return(newName);
}
private string GetHeader(IOutputFile output)
{
string fileExtension = output.FileMetaData.FileExtension;
IFileMetaData fileMetaData = output.FileMetaData;
var codeGenTypeDescription = output.FileMetaData.CodeGenType;
var overwriteBehaviourDescription = output.FileMetaData.OverwriteBehaviour.GetDescription();
var additionalHeaders = output.Template.GetAllAdditionalHeaderInformation();
var additionalHeaderInformation = !additionalHeaders.Any()
? string.Empty
: Environment.NewLine + Environment.NewLine + additionalHeaders.Select(x => $" - {x}").Aggregate((x, y) => x + Environment.NewLine + y) + Environment.NewLine;
var header = $@"
******************************************************************************
___ _ _
|_ _|_ __ | |_ ___ _ __ | |_
| || '_ \| __/ _ \ '_ \| __|
| || | | | || __/ | | | |_
|___|_| |_|\__\___|_| |_|\__|
Gen Type : {codeGenTypeDescription} {additionalHeaderInformation}
******************************************************************************".TrimStart();
switch (fileExtension.ToLower())
{
// for /*..*/ style comment file extensions
case "cs":
case "js":
case "ts":
return($@"/*{header}*/{Environment.NewLine}");
// for <!--..--> style comment file extensions
case "xaml":
case "html":
case "xml":
case "config":
return($@"<!--{header}*-->{Environment.NewLine}");
default:
return(null);
}
}
