protected override Task <SolutionInfo> GetSolutionInfoAsync(RepoFile repoFile) { var repo = repoFile.PrimaryProject.Repo; var dispatcher = repo.AnalysisServices.TaskDispatcher; var services = repo.AnalysisServices; var logger = repo.AnalysisServices.Logger; var solutionFilePath = repoFile.FilePath; var binLog = binLogFinder?.Invoke(solutionFilePath); if (!File.Exists(binLog)) { logger?.LogWarning($"Couldn't find .binlog for {solutionFilePath}, reverting to MSBuildWorkspace"); return(base.GetSolutionInfoAsync(repoFile)); } var solutionFile = SolutionFile.Parse(new SourceTextReader(SourceText.From(services.ReadAllText(solutionFilePath)))); SolutionInfoBuilder solutionInfo = new SolutionInfoBuilder(solutionFilePath, repo, binLog); foreach (var projectBlock in solutionFile.ProjectBlocks) { solutionInfo.StartLoadProject(projectBlock.ProjectPath); } if (solutionInfo.HasProjects) { repoFile.HasExplicitAnalyzer = true; } return(Task.FromResult(solutionInfo.Build())); }
// ----< demonstrates req #3c - checkout >-------------------- private void DemoCheckOut() { RepoClientState state = (RepoClientState)this.DataContext; RepoFile repoFile = new RepoFile { PackageName = "Process", Namespace = "Process", Filename = "Process.h", Version = 1 }; state.ServerCommService.Requests.PostCheckOut( repoFile.PackageName, repoFile.Namespace, repoFile.Filename, repoFile.Version, false, state.ServerConnProps.UserId, (CheckOutResponse response) => { Console.WriteLine($"\n\n{new String('-', 60)}"); Console.WriteLine(" Demonstrating Requirement #3c - Check-Out"); Console.WriteLine($"{new String('-', 60)}\n"); Console.WriteLine($" > Check-Out requestId [{response.RequestId}] succeeded"); Console.WriteLine($" > Server responded to request with status success: {response.Success}"); Console.WriteLine($"\n Test Passed\n"); }, true); }
protected override void AnnotateFile(AnalysisServices services, RepoFile file, BoundSourceFileBuilder binder) { string solutionDirectory = Path.GetDirectoryName(file.FilePath); try { var defaultRepoProject = file.PrimaryProject.Repo.DefaultRepoProject; var repoRoot = defaultRepoProject.ProjectDirectory; var solutionFile = SolutionFile.Parse(new SourceTextReader(binder.SourceText)); foreach (var projectBlock in solutionFile.ProjectBlocks) { var projectPath = projectBlock.ParsedProjectPath.Value; if (string.IsNullOrEmpty(projectPath)) { continue; } var fullProjectPath = Path.GetFullPath(Path.Combine(solutionDirectory, projectPath)); var projectFileReference = BoundSourceFileBuilder.CreateFileReferenceSymbol( defaultRepoProject.GetLogicalPath(fullProjectPath), defaultRepoProject.ProjectId); var span = projectBlock.ParsedProjectName.Span; AnnotateReference(binder, projectFileReference, span); span = projectBlock.ParsedProjectPath.Span; AnnotateReference(binder, projectFileReference, span); } } catch (Exception ex) { services.Logger.LogExceptionError("AnnotateSolution", ex); } }
private static void _FillFolder(DirectoryInfo directory, RepoFolder folder) { foreach (var dirinfo in directory.GetDirectories()) { if (dirinfo.Attributes.HasFlag(FileAttributes.Hidden) || dirinfo.Name.StartsWith(".")) { continue; } var subFolder = new RepoFolder(dirinfo.Name, new Uri(folder.Uri, dirinfo.Name)); _FillFolder(dirinfo, subFolder); folder.Folders.Add(subFolder); } foreach (var fileinfo in directory.GetFiles()) { if (fileinfo.Attributes.HasFlag(FileAttributes.Hidden) || fileinfo.Name.StartsWith(".")) { continue; } var file = new RepoFile(fileinfo.Name); folder.Files.Add(file); } var defaultfile = (from f in folder.Files where f.Name.ToLowerInvariant().StartsWith("index.") || f.Name.ToLowerInvariant().StartsWith("default.") where f.Type == FileType.html select f).FirstOrDefault(); if (defaultfile != null) { folder.Files.Remove(defaultfile); folder.Files.Insert(0, defaultfile); } }
protected override async Task <SolutionInfo> GetSolutionInfoAsync(RepoFile repoFile) { var repo = repoFile.PrimaryProject.Repo; var dispatcher = repo.AnalysisServices.TaskDispatcher; var services = repo.AnalysisServices; var logger = repo.AnalysisServices.Logger; var solutionFile = SolutionFile.Parse(new SourceTextReader(SourceText.From(services.ReadAllText(repoFile.FilePath)))); SolutionInfoBuilder solutionInfo = new SolutionInfoBuilder(repoFile.FilePath, repo); foreach (var projectBlock in solutionFile.ProjectBlocks) { solutionInfo.StartLoadProjectAsync(projectBlock.ProjectPath); } await solutionInfo.WaitForProjects(); if (solutionInfo.HasProjects) { repoFile.HasExplicitAnalyzer = true; } return(solutionInfo.Build()); }
protected virtual void AnnotateFile( AnalysisServices services, RepoFile file, XmlSourceFileBuilder binder, XmlDocumentSyntax document) { }
protected override void AnnotateFile( AnalysisServices services, RepoFile file, XmlSourceFileBuilder binder, XmlDocumentSyntax document) { Analyze(services, file, binder, document); }
private void WriteZipInTheTextBlock(string filePath) { using (RepoFile repo = new RepoFile()) { IEnumerable <string> myLines = repo.ExtractZipFiles(filePath); WriteInTextCountryInfo(myLines); } Dispatcher.Invoke(() => { }); }
public static FileDTO Map(RepoFile entity) { var dto = new FileDTO { FileName = entity.FileName, FileURI = entity.FileURI, }; return(dto); }
public static void AddSolutionProjects( Repo repo, Workspace workspace, Func <Task <SolutionInfo> > solutionInfoLoader, Func <SolutionInfo, Solution> solutionSelector, bool requireProjectExists = true, string solutionName = "Anonymous solution") { var dispatcher = repo.AnalysisServices.TaskDispatcher; var logger = repo.AnalysisServices.Logger; dispatcher.QueueInvoke(async() => { try { logger.LogMessage("Loading solution: " + solutionName); var csharpSemanticServices = new Lazy <SemanticServices>(() => new SemanticServices(workspace, LanguageNames.CSharp)); var visualBasicSemanticServices = new Lazy <SemanticServices>(() => new SemanticServices(workspace, LanguageNames.VisualBasic)); var solutionInfo = await solutionInfoLoader(); Lazy <Task <Solution> > lazySolution = new Lazy <Task <Solution> >(() => { var solution = solutionSelector(solutionInfo); return(Task.FromResult(solution)); }, isThreadSafe: true); foreach (var projectInfo in solutionInfo.Projects) { RepoFile projectFile = null; if (!string.IsNullOrEmpty(projectInfo.FilePath)) { projectFile = repo.DefaultRepoProject.AddFile(projectInfo.FilePath); } if (requireProjectExists && ((projectFile == null || projectFile.HasExplicitAnalyzer))) { continue; } var repoProject = repo.CreateRepoProject( projectInfo.AssemblyName, projectFile != null ? Path.GetDirectoryName(projectFile.FilePath) : string.Empty, projectFile); AddSolutionProject(lazySolution, projectInfo, projectFile, repoProject, csharpSemanticServices, visualBasicSemanticServices); } } catch (Exception ex) { logger.LogExceptionError($"Loading solution: {solutionName}", ex); } }); }
private async void AnnotateAndUpload( AnalysisServices services, RepoFile file, BoundSourceFileBuilder binder) { await AnnotateFileAsync(services, file, binder); var boundSourceFile = binder.Build(); UploadSourceFile(services, file, boundSourceFile); }
protected override void Analyze(AnalysisServices services, RepoFile file) { ProjectAnalyzer.DocumentAnalysisTasks.Add(services.TaskDispatcher.Invoke(async() => { try { ReportStartAnalyze(file); var project = ProjectAnalyzer.Project; if (project == null) { file.PrimaryProject.Repo.AnalysisServices.Logger.LogError("Project is null"); return(null); } var document = project.GetDocument(DocumentInfo.Id); var text = await document.GetTextAsync(); SourceFile sourceFile = new SourceFile() { Info = AugmentSourceFileInfo(new SourceFileInfo() { Language = project.Language, Path = file.LogicalPath, RepoRelativePath = file.RepoRelativePath }), }; BoundSourceFileBuilder binder = CreateBuilder(sourceFile, file, file.PrimaryProject.ProjectId); binder.SourceText = text; DocumentAnalyzer analyzer = new DocumentAnalyzer( ProjectAnalyzer.semanticServices, document, ProjectAnalyzer.CompilationServices, file.LogicalPath, ProjectAnalyzer.ProjectContext, binder); var boundSourceFile = await analyzer.CreateBoundSourceFile(); ProjectAnalyzer.ProjectContext.ReportDocument(boundSourceFile, file); UploadSourceFile(services, file, boundSourceFile); return(boundSourceFile); } finally { file.Analyzer = RepoFileAnalyzer.Null; ProjectAnalyzer = null; } })); }
public override bool IsCandidateProjectFile(RepoFile repoFile) { if (repoFile.FilePath.EndsWith(".sln", StringComparison.OrdinalIgnoreCase)) { if (includedSolutions == null || includedSolutions.Contains(repoFile.FilePath)) { return(true); } } return(false); }
// ----< fetches file's text from server and displays it >-------------------- private void FileTextLink_ClickAction(RepoFile repoFile) { RepoClientState state = (RepoClientState)this.DataContext; state.BrowseProps.SelectedRepoFile = repoFile; FileTextPopupWindow fileTextPopup = new FileTextPopupWindow(); fileTextPopup.DataContext = state; fileTextPopup.Title = $"{repoFile.Filename} v{repoFile.Version}"; fileTextPopup.Show(); }
private SourceFile CreateSourceFile(AnalysisServices services, RepoFile file) { return(new SourceFile() { Info = AugmentSourceFileInfo(new SourceFileInfo() { Language = "text", Path = file.LogicalPath, RepoRelativePath = file.RepoRelativePath }), Content = services.ReadAllText(file.FilePath) }); }
public static void AddSolutionProject( Lazy <Task <Solution> > lazySolution, ProjectInfo projectInfo, RepoFile projectFile, RepoProject repoProject, Lazy <SemanticServices> csharpSemanticServices = null, Lazy <SemanticServices> visualBasicSemanticServices = null) { var semanticServices = projectInfo.Language == LanguageNames.CSharp ? csharpSemanticServices : visualBasicSemanticServices; Contract.Assert(semanticServices.Value != null); var projectAnalyzer = new ManagedProjectAnalyzer( semanticServices.Value, repoProject, projectInfo.Id, lazySolution); if (projectFile != null) { projectFile.HasExplicitAnalyzer = true; } repoProject.Analyzer = projectAnalyzer; foreach (var document in projectInfo.Documents) { if (document == null) { throw new ArgumentNullException($"Project {projectInfo.Id} has a null document."); } if (Path.GetFileName(document.FilePath).StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase)) { continue; } var file = AddDocumentToProject(repoProject, document); if (file != null && projectAnalyzer != null) { file.Analyzer = projectAnalyzer.CreateFileAnalyzer(document); } } foreach (var document in projectInfo.AdditionalDocuments) { AddDocumentToProject(repoProject, document); } }
public void GetFileMetadata(String package, String ns, String filename, int version, String userId, Action <GetFileMetadataResponse> action, bool verbose = false) { string uniqueId = GetUniqueId(); dispatcher_[uniqueId] = (CsMessage response) => { List <RepoFile> dependencies = new List <RepoFile>(); int count = 1; while (true) { if (!response.containsKey($"dependency-{count}")) { break; } string fileInfo = response.value($"dependency-{count}"); dependencies.Add(RepoFile.parse(fileInfo)); count++; } RepoFileMetadata metadata = new RepoFileMetadata { Author = response.value("author"), Description = response.value("description"), Dependencies = dependencies }; action(new GetFileMetadataResponse { Metadata = metadata, RequestId = uniqueId }); dispatcher_.Remove(uniqueId); }; CsMessage msg = new CsMessage(); msg.add("to", CsEndPoint.toString(serverEndPoint_)); msg.add("from", CsEndPoint.toString(endPoint_)); msg.add("command", "get-file-metadata"); msg.add("requestId", uniqueId); msg.add("userId", userId); if (verbose) { msg.add("verbose", "yes"); } msg.add("package", package); msg.add("namespace", ns); msg.add("filename", filename); msg.add("version", version.ToString()); translater_.postMessage(msg); }
public async Task <OperationDetailDTO> AddFileToRepoAsync(int id, string userfileName, string uniquefileName = null) { var detail = new OperationDetailDTO(); try { var repo = await _context.RepositoryModels.FindAsync(id); if (repo != null) { RepoFile newFile; if (uniquefileName != null) { newFile = new RepoFile { RepositoryModel = repo, FileName = userfileName, Path = RepoFilePath + uniquefileName, FileURI = RepoFileURI + uniquefileName }; } else { newFile = new RepoFile { RepositoryModel = repo, FileName = userfileName, Path = RepoFilePath + userfileName, FileURI = RepoFileURI + userfileName }; } await _context.RepoFiles.AddAsync(newFile); await _context.SaveChangesAsync(); detail.Succeeded = true; } else { detail.ErrorMessages.Add("Ошибка при добавлении файла: репозиторий не найден."); } return(detail); } catch (Exception e) { detail.ErrorMessages.Add("Ошибка при добавлении файла к репозиторию " + e.Message); return(detail); } }
// ----< displays a message box with the metadata information of selected file >-------------------- private void DisplayMetadata(RepoFile repoFile, RepoFileMetadata metadata) { RepoClientState state = (RepoClientState)this.DataContext; state.BrowseProps.SelectedRepoFile = repoFile; IEnumerable <String> depList = metadata.Dependencies.Select((RepoFile depFile) => $"> {depFile.Filename} v{depFile.Version}"); FileMetadataPopupWindow fileMetadataPopup = new FileMetadataPopupWindow(); fileMetadataPopup.Title = $"Metadata for {repoFile.Filename} v{repoFile.Version}"; fileMetadataPopup.Author.Text = metadata.Author; fileMetadataPopup.Description.Text = metadata.Description; fileMetadataPopup.Dependencies.Text = String.Join("\n", depList); fileMetadataPopup.Show(); }
protected BoundSourceFileBuilder CreateBuilder(SourceFile sourceFile, RepoFile repoFile, string projectId) { var builder = CreateBuilderCore(sourceFile, projectId); if (sourceFile.Info.RepoRelativePath != null && repoFile.PrimaryProject != repoFile.PrimaryProject.Repo.DefaultRepoProject) { // Add a file definition for the repo relative path in the default repo project builder.AnnotateReferences(0, 0, BoundSourceFileBuilder.CreateFileReferenceSymbol( sourceFile.Info.RepoRelativePath, repoFile.PrimaryProject.Repo.DefaultRepoProject.ProjectId, isDefinition: true)); } return(builder); }
protected BaseGenerator(JObject rootJObj, string targetDir, string filePath, OrgsMappingFile orgsMappingFile, IDictionary <string, int> lineNumberMappingDict, RepoFile repoFile, string swaggerRelativePath, string version) { Guard.ArgumentNotNull(rootJObj, nameof(rootJObj)); Guard.ArgumentNotNullOrEmpty(targetDir, nameof(targetDir)); Guard.ArgumentNotNullOrEmpty(filePath, nameof(filePath)); Guard.ArgumentNotNull(orgsMappingFile, nameof(orgsMappingFile)); RootJObj = rootJObj; TargetDir = targetDir; FilePath = filePath; OrgsMappingFile = orgsMappingFile; LineNumberMappingDict = lineNumberMappingDict; RepoFile = repoFile; SwaggerRelativePath = swaggerRelativePath; Version = version; }
static void Main(string[] args) { try { IRepo repo = new RepoFile(); Console.WriteLine("Write some words which should be stored"); string text = Console.ReadLine(); repo.Save(text); } catch (Exception e) { Console.WriteLine("Exception occurs: " + e.Message); } }
protected static void UploadSourceFile(AnalysisServices services, RepoFile file, BoundSourceFile boundSourceFile) { if (file.IsSingleton) { boundSourceFile.MakeSingleton(); } services.TaskDispatcher.QueueInvoke(() => { int uploadCount = Interlocked.Increment(ref file.PrimaryProject.Repo.UploadCount); file.PrimaryProject.Repo.AnalysisServices.Logger.WriteLine($"Uploading source: '{boundSourceFile.ProjectId}::{boundSourceFile.SourceFile.Info.Path}' ({uploadCount} of {file.PrimaryProject.Repo.FileCount})"); return(services.AnalysisTarget.UploadAsync( file, boundSourceFile)); }, TaskType.Upload); }
private void AddRepoFile(RepoFile file) { string src = GetIdByName(file.Source); lock (Files) { if (Files.ContainsKey(src)) { Files[src].Add(file); } else { Files.Add(src, new List <RepoFile>(new RepoFile[] { file })); } } RepoSize += file.Length; }
public override void CreateProjects(RepoFile repoFile) { if (!repoFile.FilePath.EndsWith(".sln", StringComparison.OrdinalIgnoreCase)) { return; } var repo = repoFile.PrimaryProject.Repo; var logger = repo.AnalysisServices.Logger; Func <Task <SolutionInfo> > solutionInfoLoader = () => GetSolutionInfoAsync(repoFile); AddSolutionProjects( repo, solutionInfoLoader, RequireProjectFilesExist, solutionName: repoFile.FilePath); }
// ----< demonstrates req #3e - view file text >-------------------- private void DemoGetFileText() { RepoClientState state = (RepoClientState)this.DataContext; state.ServerCommService.Requests.GetFileText("RepoCore", "SoftwareRepository", "RepoCore.h", 1, state.ServerConnProps.UserId, (GetFileTextResponse fileTextRes) => { Console.WriteLine($"\n\n{new String('-', 60)}"); Console.WriteLine($" Demonstrating Requirement #3e - Viewing full file text"); Console.WriteLine($"{new String('-', 60)}\n"); Console.WriteLine($" > Fetch for requestId [{fileTextRes.RequestId}] succeeded"); Console.WriteLine($" > Below are few lines of text from file RepoCore.h v1\n"); Console.WriteLine($" {new String('-', 15)}x{new String('-', 15)}"); Console.WriteLine($"\n{RepoFile.readFileText("RepoCore.h").Substring(0, 1025)}\n"); Console.WriteLine($" {new String('-', 15)}x{new String('-', 15)}"); Console.WriteLine($"\n Test Passed\n"); }, true); }
public void DeleteVersion(RepoFile version) { File.Delete(Win32PathPrefix + version.FullName); string id = GetIdByName(version.Source); lock (Files) { List <RepoFile> vers = Files[id]; if (vers.Count == 1) { Files.Remove(id); } else { vers.Remove(version); } } RepoSize -= version.Length; }
public void GetPackageFiles(String packageName, String userId, Action <GetPackageFilesResponse> action, bool verbose = false) { string uniqueId = GetUniqueId(); dispatcher_[uniqueId] = (CsMessage response) => { List <RepoFile> repoFiles = new List <RepoFile>(); int count = 1; while (true) { if (!response.containsKey($"file-{count}")) { break; } string fileInfo = response.value($"file-{count}"); repoFiles.Add(RepoFile.parse(fileInfo)); count++; } action(new GetPackageFilesResponse { RepoFiles = repoFiles, RequestId = uniqueId }); dispatcher_.Remove(uniqueId); }; CsMessage msg = new CsMessage(); msg.add("to", CsEndPoint.toString(serverEndPoint_)); msg.add("from", CsEndPoint.toString(endPoint_)); msg.add("command", "get-package-files"); msg.add("requestId", uniqueId); msg.add("userId", userId); if (verbose) { msg.add("verbose", "yes"); } msg.add("package", packageName); translater_.postMessage(msg); }
// ----< fetches file's metadata from server and displays it >-------------------- private void MetadataLink_ClickAction(RepoFile repoFile) { RepoClientState state = (RepoClientState)this.DataContext; string metadataKey = RepoFile.stringify(repoFile); if (state.BrowseProps.MetadataDict.ContainsKey(metadataKey)) { DisplayMetadata(repoFile, state.BrowseProps.MetadataDict[metadataKey]); } else { state.ServerCommService.Requests.GetFileMetadata(repoFile.PackageName, repoFile.Namespace, repoFile.Filename, repoFile.Version, state.ServerConnProps.UserId, (GetFileMetadataResponse metadataRes) => { state.BrowseProps.MetadataDict[metadataKey] = metadataRes.Metadata; this.Dispatcher.Invoke(() => DisplayMetadata(repoFile, state.BrowseProps.MetadataDict[metadataKey])); }, true); } }
// ----< posts checkout request to the server >-------------------- private void Download(RepoFile repoFile) { RepoClientState state = (RepoClientState)this.DataContext; state.ServerCommService.Requests.PostCheckOut( repoFile.PackageName, repoFile.Namespace, repoFile.Filename, repoFile.Version, state.CheckOutProps.DependentsAreRequired, state.ServerConnProps.UserId, (CheckOutResponse response) => { RepoFile.copyToDest(repoFile, state.CheckOutProps.CheckoutFolder); string message = $"Succesfully downloaded file '{repoFile.Filename}' " + $"to {state.CheckOutProps.CheckoutFolder}"; MessageBox.Show(message, "Check-Out"); }, true); }