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); } }