Esempio n. 1
0
    static Tests()
    {
        BuildServerDetector.Detected = false;
        DiffRunner.Disabled          = false;
        DiffTools.AddTool(
            name: "MyTools",
            autoRefresh: true,
            isMdi: false,
            supportsText: true,
            requiresTarget: true,
            arguments: (path1, path2) => $"\"{path1}\" \"{path2}\"",
            exePath: diffToolPath,
            binaryExtensions: new[] { "knownBin" });
        var binPath = AllFiles.Files["jpg"];
        var newPath = Path.ChangeExtension(binPath.Path, "knownBin");

        File.Copy(binPath.Path, newPath, true);
        AllFiles.UseFile(Category.Image, newPath);

        VerifierSettings.RegisterFileConverter <TypeToSplit>(
            (split, _) => new ConversionResult(
                split.Info,
                new List <Target>
        {
            new("txt", split.Property1),
            new("txt", split.Property2)
        }));
Esempio n. 2
0
        static void Main(string[] args)
        {
            var path     = $@"F:\Clients\MuhraSoft\MuhraSoftSystemV1Store\MuhraSoftSystem - Temp\MuhraSoftSystem\MuhraSoftSystem.csproj";
            var filename = $@"{path}\MuhraSoftSystem.csproj";

            XDocument  doc = XDocument.Load(filename);
            XNamespace ns  = "http://schemas.microsoft.com/developer/msbuild/2003";

            void DumpMatches(IEnumerable <string> values)
            {
                foreach (string x in values)
                {
                    AllFiles.Add(x);
                }
            }

            DumpMatches(doc.Descendants(ns + "Compile").Select(x => x.Attribute("Include").Value));
            DumpMatches(doc.Descendants(ns + "AssemblyOriginatorKeyFile").Select(x => x.Value));

            var dirInfo                 = new DirectoryInfo(path);
            var allFilesOnDisk          = dirInfo.GetFiles("*.*", SearchOption.AllDirectories).Select(s => s.FullName).ToList();
            var allFilesFromProjectFile = AllFiles.Select(s => $@"{path}\MuhraSoftSystem\{s}").ToList();
            var excludedFiles           = allFilesOnDisk.Except(allFilesFromProjectFile).ToList();
            var ff = excludedFiles.Where(w => w.Contains("All2") && w.EndsWith(".cs")).ToList();

            foreach (var f in ff)
            {
                if (f.EndsWith(".cs"))
                {
                    File.Delete(f);
                    Debug.WriteLine(f);
                }
            }
        }
        /// <summary>
        /// Refreshes the current view of files
        /// </summary>
        /// <param name="allFiles">Clears down all files to be refreshed</param>
        public void Refresh(bool allFiles)
        {
            if (CurrentFileList != null)
            {
                CurrentFileList.Clear();
            }

            if (allFiles)
            {
                if (AllFiles != null)
                {
                    AllFiles.Clear();
                }

                SelectedFile = null;
            }

            if (SelectedFile == null)
            {
                OnLoadData();
            }
            else
            {
                SelectedFile.Children = null;

                ExpandFile(SelectedFile);
            }
        }
Esempio n. 4
0
    static Tests()
    {
        BuildServerDetector.Detected = false;
        DiffTools.AddTool(
            name: "MyTools",
            autoRefresh: true,
            isMdi: false,
            supportsText: true,
            requiresTarget: true,
            arguments: (path1, path2) => $"\"{path1}\" \"{path2}\"",
            exePath: diffToolPath,
            binaryExtensions: new[] { "knownBin" });
        var binPath = AllFiles.Files["jpg"];
        var newPath = Path.ChangeExtension(binPath.Path, "knownBin");

        File.Copy(binPath.Path, newPath, true);
        AllFiles.UseFile(Category.Image, newPath);

        SharedVerifySettings.RegisterFileConverter <TypeToSplit>(
            "txt",
            (split, settings) => new ConversionResult(
                split.Info,
                new List <Stream>
        {
            new MemoryStream(FileHelpers.Utf8NoBOM.GetBytes(split.Property1)),
            new MemoryStream(FileHelpers.Utf8NoBOM.GetBytes(split.Property2))
        }));
        DiffRunner.MaxInstancesToLaunch(int.MaxValue);
    }
Esempio n. 5
0
        public DatReader GetReaderForFile(uint fileId)
        {
            if (AllFiles.TryGetValue(fileId, out var file))
            {
                DatReader dr;

                if (stream != null)
                {
                    lock (streamMutex)
                        dr = new DatReader(stream, file.FileOffset, file.FileSize, Header.BlockSize);
                }
                else
                {
                    dr = new DatReader(FilePath, file.FileOffset, file.FileSize, Header.BlockSize);
                }

                return(dr);
            }

            if ((fileId & 0xFFFF) == 0xFFFE) // These are LandBlockInfo objects. Not every landblock has extra info (buildings, etc..)
            {
                log.DebugFormat("Unable to find object_id {0:X8} in {1}", fileId, Enum.GetName(typeof(DatDatabaseType), Header.DataSet));
            }
            else
            {
                log.InfoFormat("Unable to find object_id {0:X8} in {1}", fileId, Enum.GetName(typeof(DatDatabaseType), Header.DataSet));
            }

            return(null);
        }
Esempio n. 6
0
 public override Task GetResults(ISearchResultCallback searchResultCallback, SearchPopupSearchPattern pattern, CancellationToken token)
 {
     return(Task.Run(delegate {
         var files = AllFiles.ToList();
         var matcher = StringMatcher.GetMatcher(pattern.Pattern, false);
         var savedMatches = new Dictionary <string, MatchResult> ();
         foreach (ProjectFile file in files)
         {
             if (token.IsCancellationRequested)
             {
                 break;
             }
             int rank;
             string matchString = System.IO.Path.GetFileName(file.FilePath);
             if (MatchName(savedMatches, matcher, matchString, out rank))
             {
                 searchResultCallback.ReportResult(new FileSearchResult(pattern.Pattern, matchString, rank, file, true));
             }
             matchString = FileSearchResult.GetRelProjectPath(file);
             if (MatchName(savedMatches, matcher, matchString, out rank))
             {
                 searchResultCallback.ReportResult(new FileSearchResult(pattern.Pattern, matchString, rank, file, true));
             }
         }
     }, token));
 }
Esempio n. 7
0
        /// <summary>
        /// Initializes a new instance of the <see cref="FileExpressionList"/> class.
        /// </summary>
        /// <param name="rawFileListString">The unprocessed list of file expressions.</param>
        /// <param name="project">The project where the expression list exists.</param>
        /// <param name="task">The task where the expression list exists.</param>
        public FileExpressionList(string rawFileListString, ProjectInstance project, ProjectTaskInstance task)
        {
            IList <string> expressions = rawFileListString.SplitStringList();
            var            seenFiles   = new HashSet <string>(PathComparer.Instance);

            foreach (string expression in expressions)
            {
                FileExpressionBase parsedExpression = FileExpressionFactory.ParseExpression(expression, project, task);
                Expressions.Add(parsedExpression);

                foreach (string file in parsedExpression.EvaluatedFiles)
                {
                    if (string.IsNullOrWhiteSpace(file))
                    {
                        continue;
                    }

                    if (seenFiles.Add(file))
                    {
                        DedupedFiles.Add(file);
                    }

                    AllFiles.Add(file);
                }
            }
        }
Esempio n. 8
0
        /// <summary>
        /// Dictionary<files,datetime last write> всех файлов в Projdir
        /// </summary>
        public filesdates AllFiles()
        {
            filesdates res = new filesdates();

            if (!IsOnline)
            {
                return(res);
            }
            string[] AllFiles;
            if (_allfiles == null)
            {
                // tmr.Start("===GetFilesInDir = " + Dir, 22);
                // CONSTS.AddToTempLine("Получение файлов из " + Dir);
                AllFiles = GetfilesIndir(Dir); //запуск поиска всех файлов директории проекта
                                               //  tmr.Stop(22);
            }
            else
            {
                return(_allfiles);
            }
            var n = AllFiles.Count();

            //tmr.Stop(22);
            // tmr.Start("Перевод в структуру filesdates ",23);
            foreach (var file in AllFiles)
            {
                res.Add(file, File.GetLastWriteTime(file));
            }
            // tmr.Stop(23);
            _allfiles = res;
            return(res);
        }
Esempio n. 9
0
    public void CreateFile()
    {
        var pathOfFileToCreate = "file.jpg";

        File.Delete(pathOfFileToCreate);
        #region CreateFile
        AllFiles.CreateFile(pathOfFileToCreate);
        #endregion
        Assert.True(File.Exists(pathOfFileToCreate));
        File.Delete(pathOfFileToCreate);

        AllFiles.CreateFile("foo.txt", true);
        Assert.True(File.Exists("foo.txt"));
        File.Delete("foo.txt");

        Assert.True(AllFiles.TryCreateFile(pathOfFileToCreate));
        Assert.True(File.Exists(pathOfFileToCreate));
        File.Delete(pathOfFileToCreate);

        Assert.False(AllFiles.TryCreateFile("foo.txt"));
        Assert.False(File.Exists("foo.txt"));
        File.Delete("foo.txt");

        Assert.True(AllFiles.TryCreateFile("foo.txt", true));
        Assert.True(File.Exists("foo.txt"));
        File.Delete("foo.txt");
    }
Esempio n. 10
0
        public async Task <IndexRoot> Integrate(ICollection <VirtualFile> files)
        {
            Utils.Log($"Integrating {files.Count} files");
            var allFiles = AllFiles.Concat(files)
                           .OrderByDescending(f => f.LastModified)
                           .GroupBy(f => f.FullPath).Select(g => g.Last())
                           .ToList();

            var byFullPath = Task.Run(() => allFiles.SelectMany(f => f.ThisAndAllChildren)
                                      .ToDictionary(f => f.FullPath));

            var byHash = Task.Run(() => allFiles.SelectMany(f => f.ThisAndAllChildren)
                                  .Where(f => f.Hash != Hash.Empty)
                                  .ToLookup(f => f.Hash));

            var byName = Task.Run(() => allFiles.SelectMany(f => f.ThisAndAllChildren)
                                  .ToLookup(f => f.Name));

            var byRootPath = Task.Run(() => allFiles.ToDictionary(f => f.AbsoluteName));

            var result = new IndexRoot(allFiles,
                                       await byFullPath,
                                       await byHash,
                                       await byRootPath,
                                       await byName);

            Utils.Log($"Done integrating");
            return(result);
        }
Esempio n. 11
0
        //public bool AreAllFilesRecommended()
        //{
        //    var extensions = new List<string>();
        //    string[] ignore = { ".map" };

        //    foreach (string file in Files)
        //    {
        //        string ext = Path.GetExtension(file).ToLowerInvariant();

        //        if (!ignore.Contains(ext) && !extensions.Contains(ext))
        //            extensions.Add(ext);

        //        if (extensions.Count >= 2)
        //            return true;
        //    }

        //    return false;
        //}

        internal async Task DownloadFilesAsync(string downloadDir)
        {
            if (Directory.Exists(downloadDir))
            {
                return;
            }

            var list = DownloadFiles(downloadDir, Files);

            OnDownloading(downloadDir);
            await Task.WhenAll(list);

            var remaining = AllFiles.Where(f => !Files.Contains(f));

            if (remaining.Any())
            {
                // Fire and forget to return call immediately. Download the rest of the files
                // TODO: Is there a more elegant way than using the threadpool like this?
                System.Threading.ThreadPool.QueueUserWorkItem(async(o) =>
                {
                    OnDownloadingRemainingFiles(downloadDir);

                    await Task.WhenAll(DownloadFiles(downloadDir, remaining));
                });
            }
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="FileExpressionList"/> class.
        /// </summary>
        /// <param name="rawFileListString">The unprocessed list of file expressions.</param>
        /// <param name="project">The project where the expression list exists.</param>
        /// <param name="task">The task where the expression list exists.</param>
        public FileExpressionList(string rawFileListString, ProjectInstance project, ProjectTaskInstance task)
        {
            List <string> expressions = rawFileListString.SplitStringList();

            NumExpressions = expressions.Count;

            var seenFiles = new HashSet <string>(PathComparer.Instance);

            foreach (string expression in expressions)
            {
                List <string> evaluatedFiles = FileExpression.EvaluateExpression(expression, project, task, out bool isBatched);
                if (isBatched)
                {
                    NumBatchExpressions++;
                }

                foreach (string file in evaluatedFiles)
                {
                    if (string.IsNullOrWhiteSpace(file))
                    {
                        continue;
                    }

                    if (seenFiles.Add(file))
                    {
                        DedupedFiles.Add(file);
                    }

                    AllFiles.Add(file);
                }
            }
        }
Esempio n. 13
0
        public async Task <IndexRoot> Integrate(ICollection <VirtualFile> files)
        {
            Utils.Log($"Integrating {files.Count} files");
            var allFiles = AllFiles.Concat(files).GroupBy(f => f.Name).Select(g => g.Last()).ToImmutableList();

            var byFullPath = Task.Run(() => allFiles.SelectMany(f => f.ThisAndAllChildren)
                                      .ToImmutableDictionary(f => f.FullPath));

            var byHash = Task.Run(() => allFiles.SelectMany(f => f.ThisAndAllChildren)
                                  .Where(f => f.Hash != null)
                                  .ToGroupedImmutableDictionary(f => f.Hash));

            var byName = Task.Run(() => allFiles.SelectMany(f => f.ThisAndAllChildren)
                                  .ToGroupedImmutableDictionary(f => f.Name));

            var byRootPath = Task.Run(() => allFiles.ToImmutableDictionary(f => f.Name));

            var result = new IndexRoot(allFiles,
                                       await byFullPath,
                                       await byHash,
                                       await byRootPath,
                                       await byName);

            Utils.Log($"Done integrating");
            return(result);
        }
Esempio n. 14
0
        public override void Hotload(List <string> changedFiles)
        {
            // TODO smarter hotloading.  Handle removed files.
            var loadedFileNames = new HashSet <string>(AllFiles.Keys);

            foreach (string file in FindConfigsInBaseDir())
            {
                string fileName = GetFileNameFromPath(file);
                loadedFileNames.Remove(fileName);
                if (!AllFiles.TryGetValue(fileName, out var fileInfo))
                {
                    // New file, add it.
                    var newFileInfo = ReadFile(file);
                    AllFiles.Add(newFileInfo.Name, newFileInfo);
                    changedFiles.Add(newFileInfo.Name);
                    continue;
                }

                var fileSize = new FileInfo(file).Length;
                var modified = File.GetLastWriteTimeUtc(file);

                // Timestamp or size need to differ before we bother generating a checksum of the file.
                // Timestamps are considered different if there's at least 1 second between them.
                if (fileSize == fileInfo.Size && Math.Abs((modified - fileInfo.Modified).TotalSeconds) < 1f)
                {
                    continue;
                }

                using (var fileStream = File.OpenRead(file)) {
                    int checksum = Internal.ChecksumUtils.Checksum(fileStream);
                    fileStream.Seek(0, SeekOrigin.Begin);

                    // Update the modified timestamp and file size even if the checksum is the same.
                    // Because we didn't early out a few lines above, we know that at least one of these values
                    // is stale.
                    fileInfo.Modified = modified;
                    fileInfo.Size     = fileSize;

                    if (checksum == fileInfo.Checksum)
                    {
                        // The files are identical.
                        continue;
                    }

                    // File has changed. Hotload it.
                    fileInfo.Checksum = checksum;
                    fileInfo.Modified = modified;
                    fileInfo.Parsed   = Configs.LoadDocFromStream(fileStream, file);

                    changedFiles.Add(fileName);
                }
            }

            foreach (string deletedFile in loadedFileNames)
            {
                AllFiles.Remove(deletedFile);
                changedFiles.Add(deletedFile);
            }
        }
Esempio n. 15
0
    public void Aliases()
    {
        var path = AllFiles.GetPathFor("jpeg");

        Assert.True(AllFiles.IsEmptyFile(path));

        Assert.Contains("jpeg", AllFiles.ImageExtensions);
    }
 private void GenerateFiles()
 {
     AllFiles.Clear();
     foreach (var file in _fileRenamerModel.Files)
     {
         AllFiles.Add(new FileViewModel(file));
     }
 }
Esempio n. 17
0
 public override void Preload()
 {
     foreach (string file in FindConfigsInBaseDir())
     {
         var fileInfo = ReadFile(file);
         AllFiles.Add(fileInfo.Name, fileInfo);
     }
 }
Esempio n. 18
0
    public void UseFile()
    {
        var pathToFile = SourceFile;

        #region UseFile
        AllFiles.UseFile(Category.Document, pathToFile);
        Assert.Contains(pathToFile, AllFiles.DocumentPaths);
        #endregion
    }
Esempio n. 19
0
        public override IEnumerable <string> MatchingFiles()
        {
            var allModifiedFiles = _modifiedFiles
                                   .Union(_modifiedDirectories
                                          .SelectMany(d => Directory.EnumerateFiles(d, "*.*", SearchOption.AllDirectories)))
                                   .ToHashSet();

            return(AllFiles.Where(f => allModifiedFiles.Any(m => m.ToLower().EndsWith(f.ToLower()))));
        }
Esempio n. 20
0
        public void Filter()
        {
            // Filter all files in the directory for those satisfying the given filters
            Files.ReplaceAll(AllFiles.Where(x =>
                                            (FilterExtension == "" || x.OldExtension == FilterExtension) &&
                                            (FilterFullName ? x.OldFullName : x.OldName).RegexContains(FilterRegex ? FilterPattern : Regex.Escape(FilterPattern))));

            Preview();
        }
Esempio n. 21
0
 public void OpenDirectory(string directory)
 {
     WorkingDirectory = directory.Replace('\\', '/');
     AllFiles.ReplaceAll(Directory.GetFiles(WorkingDirectory).Select(x => new FileModel(x.Replace('\\', '/'))));
     new Sort()
     {
         Mode = SortMode.Natural
     }.ApplyTo(AllFiles);
     Filter();
 }
        private FileResult DownloadFile(AllFiles userFiles)
        {
            //AllFiles userFile = RepositoryAllFiles.AllFiles.First(uf => uf.FileId == userFiles.FileId);
            string path = Server.MapPath("~/AllUsersFiles/") +
                          RepositoryGroupFiles.GetFileGuidById(userFiles.FileId) + @"/" + userFiles.FileId + @"/" + userFiles.FileName;

            byte[] fileBytes = System.IO.File.ReadAllBytes(path);

            return(File(fileBytes, userFiles.FileExtension, userFiles.FileName));
        }
Esempio n. 23
0
 public void GetPathFor()
 {
     #region GetPathFor
     var path = AllFiles.GetPathFor("jpg");
     #endregion
     var path2 = AllFiles.GetPathFor(".jpg");
     Assert.NotNull(path);
     Assert.NotNull(path2);
     Assert.True(File.Exists(path));
     Assert.True(File.Exists(path2));
 }
Esempio n. 24
0
        public DatReader GetReaderForFile(uint fileId)
        {
            if (AllFiles.TryGetValue(fileId, out var file))
            {
                DatReader dr = new DatReader(FilePath, file.FileOffset, file.FileSize, Header.BlockSize);
                return(dr);
            }

            log.InfoFormat("Unable to find object_id {0} in {1}", fileId, Enum.GetName(typeof(DatDatabaseType), Header.DataSet));
            return(null);
        }
Esempio n. 25
0
 private void cbShowSelectedElements_CheckedChanged(object sender, EventArgs e)
 {
     if ((sender as CheckBox).Checked)
     {
         numberedFileInfoBindingSource.DataSource = AllFiles.Where(f => f.ToDelete);
     }
     else
     {
         numberedFileInfoBindingSource.DataSource = AllFiles;
     }
 }
Esempio n. 26
0
        protected EvaluationResult Evaluate(string[] predictedDefectFiles)
        {
            var allFiles = AllFiles.Select(x => x.Path).ToArray();

            return(new EvaluationResult(
                       DefectFiles,
                       allFiles.Except(DefectFiles).ToArray(),
                       predictedDefectFiles,
                       allFiles.Except(predictedDefectFiles).ToArray()
                       ));
        }
Esempio n. 27
0
 public void Unknown_extension()
 {
     Assert.Throws <Exception>(() => AllFiles.GetPathFor("txt"));
     Assert.False(AllFiles.TryGetPathFor("txt", out var result));
     Assert.Null(result);
     Assert.False(AllFiles.TryGetPathFor(".txt", out result));
     Assert.Null(result);
     Assert.False(AllFiles.TryCreateFile("foo.txt"));
     Assert.Null(result);
     Assert.Throws <Exception>(() => AllFiles.GetPathFor(".txt"));
     Assert.Throws <Exception>(() => AllFiles.CreateFile("foo.txt"));
 }
Esempio n. 28
0
        private List <string> FilterList(string extension)
        {
            return(AllFiles.Where(file => file.Contains(extension)).ToList());

            //var newList = new List<string>();
            //foreach (string file in AllFiles) {
            //    if (file.Contains(extension)) {
            //        newList.Add(file);
            //    }
            //}
            //return newList;
        }
Esempio n. 29
0
 public void CreateRoot(File newFile = null)
 {
     if (newFile == null)
     {
         AllFiles.Add(File.GetRoot(this));
     }
     else
     {
         newFile.Parent = null;
         AllFiles.Add(newFile);
     }
 }
Esempio n. 30
0
 public DatReader GetReaderForFile(uint object_id)
 {
     if (AllFiles.ContainsKey(object_id))
     {
         DatReader dr = new DatReader(FilePath, AllFiles[object_id].FileOffset, AllFiles[object_id].FileSize, SectorSize);
         return(dr);
     }
     else
     {
         log.InfoFormat("Unable to find object_id {0} in {1}", object_id.ToString(), Enum.GetName(typeof(DatDatabaseType), DatType));
         return(null);
     }
 }
Esempio n. 31
0
 public void Update(AllFiles allFiles)
 {
     Update(allFiles, RealPath);
 }
Esempio n. 32
0
        protected void Update(AllFiles allFiles, string realPathDir)
        {
            string readDir = Path.Combine(Directory.GetCurrentDirectory(), realPathDir);
            string realPath = null;

            this.Contents.Clear();

            foreach (string file in Directory.GetFiles(readDir))
            {
                realPath = Path.Combine(realPathDir, Path.GetFileName(file));
                if (!allFiles.Any(f =>
                    Path.Equals(f.RealPath, realPath)))
                    this.Add(new OtherFile()
                    {
                        Name = Path.GetFileName(file),
                        RealPath = realPath,
                    });
            }
            foreach (string dir in Directory.GetDirectories(readDir))
            {
                realPath = Path.Combine(realPathDir, Path.GetFileName(dir));
                OtherFilesFolder child = new OtherFilesFolder()
                {
                    Name = Path.GetFileName(dir),
                    RealPath = realPath,
                };
                child.Update(allFiles,  Path.Combine(realPathDir, child.Name));
                this.Add(child);
            }
        }
Esempio n. 33
0
        private void UpdateOtherFiles(OtherFilesFolder folder, AllFiles allFiles, string savePathDir)
        {
            string pathOffset = Path.GetDirectoryName(SavePath);
            string realPath = null;

            foreach (string file in Directory.GetFiles(savePathDir))
            {
                realPath = file.Substring(pathOffset.Length + (pathOffset.EndsWith("\\")? 0 : 1));
                if (!allFiles.Any(f =>
                    Path.Equals(f.RealPath, realPath)))
                    folder.Add(new OtherFile()
                    {
                        Name = Path.GetFileName(file),
                        RealPath = realPath
                    });
            }
            foreach (string dir in Directory.GetDirectories(savePathDir))
            {
                OtherFilesFolder child = new OtherFilesFolder()
                {
                    Name = Path.GetFileName(dir),
                };
                UpdateOtherFiles(child, allFiles, dir+"\\");
                folder.Add(child);
            }
        }
Esempio n. 34
0
        private void UpdateOtherFiles()
        {
            OtherFilesFolder off = (OtherFilesFolder)BaseFolder.Contents.FirstOrDefault(f => f is OtherFilesFolder);
            AllFiles allFiles = new AllFiles(BaseFolder);

            if(off == null){
                off = new OtherFilesFolder();
                BaseFolder.Add(off);
            }
            else{
                off.Contents.Clear();
            }

            off.Update(allFiles);
        }
Esempio n. 35
0
        private void ExecuteRefresh(object sender, ExecutedRoutedEventArgs args)
        {
            AllFiles allFiles = new AllFiles(Project.BaseFolder);

            (args.Parameter as OtherFilesFolder).Update(allFiles);
        }