Max file size (#24)

CommonLoon102 · web-flow · commit 863d6772dc80 · 2020-10-07T22:28:55.000+02:00
* Max file size setting added

* Remove unused using

Co-authored-by: CommonLoon102 &lt;CommonLoon102@users.noreply.github.com&gt;
diff --git a/RegexFileSearcher/RegexFileSearcher/Extensions.cs b/RegexFileSearcher/RegexFileSearcher/Extensions.cs
@@ -0,0 +1,20 @@
+﻿using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace RegexFileSearcher
+{
+    internal static class Extensions
+    {
+        public static IEnumerable<FilePath> NotZippedFiles(this IEnumerable<FilePath> filePaths)
+        {
+            return filePaths.Where(fp => !IsZipFile(fp.Path));
+        }
+
+        public static bool IsZipFile(this string fileName)
+        {
+            string extension = Path.GetExtension(fileName).ToLower();
+            return extension == ".zip";
+        }
+    }
+}
diff --git a/RegexFileSearcher/RegexFileSearcher/MainForm.init.xeto.cs b/RegexFileSearcher/RegexFileSearcher/MainForm.init.xeto.cs
@@ -16,7 +16,7 @@ public partial class MainForm : Form
         private readonly CheckBox chkRightToLeft;
         private readonly CheckBox chkSingleLine;
         private readonly CheckBox chkSearchInZipFiles;
-        private readonly NumericStepper nudTimeout;
+        private readonly NumericStepper nudMaxFileSize;
         private readonly TextBox txtContentRegex;
         private readonly CheckBox chkContentCompiled;
         private readonly CheckBox chkContentCultureInvariant;
@@ -55,7 +55,7 @@ private MainForm(bool initializeControls)
             chkRightToLeft = FindChild<CheckBox>("chkRightToLeft");
             chkSingleLine = FindChild<CheckBox>("chkSingleLine");
             chkSearchInZipFiles = FindChild<CheckBox>("chkSearchInZipFiles");
-            nudTimeout = FindChild<NumericStepper>("nudTimeout");
+            nudMaxFileSize = FindChild<NumericStepper>("nudMaxFileSize");
             txtContentRegex = FindChild<TextBox>("txtContentRegex");
             chkContentCompiled = FindChild<CheckBox>("chkContentCompiled");
             chkContentCultureInvariant = FindChild<CheckBox>("chkContentCultureInvariant");
diff --git a/RegexFileSearcher/RegexFileSearcher/MainForm.xeto b/RegexFileSearcher/RegexFileSearcher/MainForm.xeto
@@ -42,19 +42,20 @@
             </TableCell>
             <TableCell>
               <StackLayout Orientation="Vertical" Padding="10,0,0,0">
-                <CheckBox ID="chkSearchInZipFiles" ToolTip="Search in zip files recursively">Search in .zip Files</CheckBox>
+                <CheckBox ID="chkSearchInZipFiles" Checked="True" ToolTip="Search in zip files recursively">Search in .zip Files</CheckBox>
                 <StackLayout VerticalContentAlignment="Center" ToolTip="Stop search after specified seconds" Orientation="Horizontal">
-                  <Label>Timeout</Label>
+                  <Label ToolTip="Skip files that are larger than the specified size (zip files are handled like they were folders)">Max File Size</Label>
                   <Panel Padding="5,0,5,0">
-                    <NumericStepper ID="nudTimeout"
-                                    MinValue="1"
-                                    MaxValue="100"
+                    <NumericStepper ID="nudMaxFileSize"
+                                    MinValue="0"
+                                    MaxValue="1024"
                                     MaximumDecimalPlaces="0"
-                                    Value="2"
+                                    Value="5"
                                     Increment="1"
-                                    Width="90" />
+                                    Width="50"
+                                    ToolTip="Use zero for unlimited" />
                   </Panel>
-                  <Label>s</Label>
+                  <Label ToolTip="1 MiB (mebibyte) is 1024*1024 bytes">MiB</Label>
                 </StackLayout>
               </StackLayout>
             </TableCell>
diff --git a/RegexFileSearcher/RegexFileSearcher/MainForm.xeto.cs b/RegexFileSearcher/RegexFileSearcher/MainForm.xeto.cs
@@ -13,6 +13,8 @@ namespace RegexFileSearcher
 {
     public partial class MainForm : Form
     {
+        private const int FileNameRegexTimeoutInSeconds = 5;
+
         private readonly TreeGridItemCollection _itemCollection = new TreeGridItemCollection();
 
         private CancellationTokenSource _cancellationTokenSource;
@@ -60,7 +62,7 @@ static bool ValidateRegex(TextBox textBox)
                 IsMultiline = chkMultiline.Checked ?? false,
                 IsRightToLeft = chkRightToLeft.Checked ?? false,
                 IsSingleLine = chkSingleLine.Checked ?? false,
-                Timeout = (int)nudTimeout.Value
+                TimeoutInSeconds = FileNameRegexTimeoutInSeconds
             }.Regex;
 
         private Regex ContentRegex =>
@@ -77,14 +79,15 @@ static bool ValidateRegex(TextBox textBox)
                 IsMultiline = chkContentMultiline.Checked ?? false,
                 IsRightToLeft = chkContentRightToLeft.Checked ?? false,
                 IsSingleLine = chkContentSingleLine.Checked ?? false,
-                Timeout = (int)nudContentTimeout.Value
+                TimeoutInSeconds = (int)nudContentTimeout.Value
             }.Regex;
 
         private RegexSearcher CreateNewSearcher()
         {
             return new RegexSearcher(fpSearchPath.FilePath,
                                      SearchDepth,
                                      chkSearchInZipFiles.Checked ?? false,
+                                     (int)nudMaxFileSize.Value * 1024 * 1024,
                                      FileNameRegex,
                                      ContentRegex,
                                      _itemCollection,
diff --git a/RegexFileSearcher/RegexFileSearcher/RegexPattern.cs b/RegexFileSearcher/RegexFileSearcher/RegexPattern.cs
@@ -15,9 +15,9 @@ internal class RegexPattern
         public bool IsSingleLine { get; set; }
         public bool IsRightToLeft { get; set; }
         public bool IsCultureInvariant { get; set; }
-        public int Timeout { get; set; }
+        public int TimeoutInSeconds { get; set; }
 
-        public Regex Regex => new Regex(Pattern, RegexOptions, TimeSpan.FromSeconds(Timeout));
+        public Regex Regex => new Regex(Pattern, RegexOptions, TimeSpan.FromSeconds(TimeoutInSeconds));
 
         private RegexOptions RegexOptions
         {
diff --git a/RegexFileSearcher/RegexFileSearcher/RegexSearcher.cs b/RegexFileSearcher/RegexFileSearcher/RegexSearcher.cs
@@ -19,17 +19,20 @@ internal class RegexSearcher
         private readonly string _searchDirectory;
         private readonly bool _recurseSubdirectories;
         private readonly bool _searchInZipFiles;
+        private readonly int _maxFileSize;
         private readonly Regex _fileNameRegex;
         private readonly Regex _contentRegex;
         private readonly CancellationToken _cancellationToken;
         private readonly TreeGridItemCollection _itemCollection;
+        private readonly ZipFileWalker _zipFileWalker;
 
         private string _currentDirectory;
 
         // Waiting for init-only properties in C# 9
         public RegexSearcher(string searchDir,
                              int depth,
                              bool searchInZipFiles,
+                             int maxFileSize,
                              Regex fileRegex,
                              Regex contentRegex,
                              TreeGridItemCollection itemCollection,
@@ -39,11 +42,13 @@ public RegexSearcher(string searchDir,
             _depth = depth;
             _recurseSubdirectories = depth < 0;
             _searchInZipFiles = searchInZipFiles;
+            _maxFileSize = maxFileSize;
             _fileNameRegex = fileRegex;
             _contentRegex = contentRegex;
             _itemCollection = itemCollection;
             _cancellationToken = token;
             _searchEnded = false;
+            _zipFileWalker = new ZipFileWalker(_maxFileSize);
         }
 
         public string CurrentDirectory
@@ -113,29 +118,28 @@ private IEnumerable<IEnumerable<FilePath>> EnumerateFiles(string dir, int curren
             {
                 // Although   IgnoreInaccessible  is  true  by  default,
                 // it only applies when you use the 3 parameter overload
-                filePaths.AddRange(Directory.EnumerateFiles(dir, "*", _options).Select(f => new FilePath(f)));
+                filePaths.AddRange(new DirectoryInfo(dir).EnumerateFiles("*", _options)
+                    .Where(fi => fi.Name.IsZipFile() || _maxFileSize == 0 || fi.Length <= _maxFileSize)
+                    .Select(fi => new FilePath(fi.FullName)));
             }
             catch
             {
                 // IO exceptions e.g. directory was removed during enumeration
             }
 
-            yield return filePaths;
+            yield return filePaths.NotZippedFiles();
 
             // Any direcotry path exception has already been handled above
             foreach (var subDir in Directory.EnumerateDirectories(dir, "*", _options))
             {
-                foreach (var subFiles in EnumerateFiles(subDir, currentDepth - 1))
-                {
-                    yield return subFiles;
-                }
+                yield return EnumerateFiles(subDir, currentDepth - 1).SelectMany(f => f);
             }
 
             if (_searchInZipFiles)
             {
                 foreach (FilePath filePath in filePaths)
                 {
-                    yield return ZipFileWalker.GetZippedFiles(filePath);
+                    yield return _zipFileWalker.GetZippedFiles(filePath);
                 }
             }
         }
diff --git a/RegexFileSearcher/RegexFileSearcher/ZipFileWalker.cs b/RegexFileSearcher/RegexFileSearcher/ZipFileWalker.cs
@@ -5,12 +5,19 @@
 
 namespace RegexFileSearcher
 {
-    public static class ZipFileWalker
+    internal class ZipFileWalker
     {
-        public static IEnumerable<FilePath> GetZippedFiles(FilePath filePath)
+        private readonly int _maxFileSize;
+
+        public ZipFileWalker(int maxFileSize)
+        {
+            _maxFileSize = maxFileSize;
+        }
+
+        public IEnumerable<FilePath> GetZippedFiles(FilePath filePath)
         {
             var results = new List<FilePath>();
-            if (!IsZipFile(filePath.Path))
+            if (!filePath.Path.IsZipFile())
             {
                 return results;
             }
@@ -30,7 +37,7 @@ public static IEnumerable<FilePath> GetZippedFiles(FilePath filePath)
             return results;
         }
 
-        private static IEnumerable<FilePath> GetCompressedFilesInner(FilePath parentFilePath, Stream zipStream)
+        private IEnumerable<FilePath> GetCompressedFilesInner(FilePath parentFilePath, Stream zipStream)
         {
             var results = new List<FilePath>();
             try
@@ -39,7 +46,7 @@ private static IEnumerable<FilePath> GetCompressedFilesInner(FilePath parentFile
                 foreach (ZipEntry zipEntry in GetZipEntries(zipFile))
                 {
                     string zipEntryName = zipEntry.Name;
-                    if (IsZipFile(zipEntryName))
+                    if (zipEntryName.IsZipFile())
                     {
                         Stream entryStream = null;
                         try
@@ -72,21 +79,15 @@ private static IEnumerable<FilePath> GetCompressedFilesInner(FilePath parentFile
             return results;
         }
 
-        private static IEnumerable<ZipEntry> GetZipEntries(ZipFile zipFile)
+        private IEnumerable<ZipEntry> GetZipEntries(ZipFile zipFile)
         {
             foreach (ZipEntry zipEntry in zipFile)
             {
-                if (zipEntry.IsFile)
+                if (zipEntry.IsFile && (_maxFileSize == 0 || zipEntry.Size <= _maxFileSize))
                 {
                     yield return zipEntry;
                 }
             }
         }
-
-        private static bool IsZipFile(string fileName)
-        {
-            string extension = Path.GetExtension(fileName).ToLower();
-            return extension == ".zip";
-        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -19,17 +19,20 @@ internal class RegexSearcher`
`19`	`19`	`private readonly string _searchDirectory;`
`20`	`20`	`private readonly bool _recurseSubdirectories;`
`21`	`21`	`private readonly bool _searchInZipFiles;`
	`22`	`+ private readonly int _maxFileSize;`
`22`	`23`	`private readonly Regex _fileNameRegex;`
`23`	`24`	`private readonly Regex _contentRegex;`
`24`	`25`	`private readonly CancellationToken _cancellationToken;`
`25`	`26`	`private readonly TreeGridItemCollection _itemCollection;`
	`27`	`+ private readonly ZipFileWalker _zipFileWalker;`
`26`	`28`
`27`	`29`	`private string _currentDirectory;`
`28`	`30`
`29`	`31`	`// Waiting for init-only properties in C# 9`
`30`	`32`	`public RegexSearcher(string searchDir,`
`31`	`33`	`int depth,`
`32`	`34`	`bool searchInZipFiles,`
	`35`	`+ int maxFileSize,`
`33`	`36`	`Regex fileRegex,`
`34`	`37`	`Regex contentRegex,`
`35`	`38`	`TreeGridItemCollection itemCollection,`
`@@ -39,11 +42,13 @@ public RegexSearcher(string searchDir,`
`39`	`42`	`_depth = depth;`
`40`	`43`	`_recurseSubdirectories = depth < 0;`
`41`	`44`	`_searchInZipFiles = searchInZipFiles;`
	`45`	`+ _maxFileSize = maxFileSize;`
`42`	`46`	`_fileNameRegex = fileRegex;`
`43`	`47`	`_contentRegex = contentRegex;`
`44`	`48`	`_itemCollection = itemCollection;`
`45`	`49`	`_cancellationToken = token;`
`46`	`50`	`_searchEnded = false;`
	`51`	`+ _zipFileWalker = new ZipFileWalker(_maxFileSize);`
`47`	`52`	`}`
`48`	`53`
`49`	`54`	`public string CurrentDirectory`
`@@ -113,29 +118,28 @@ private IEnumerable<IEnumerable<FilePath>> EnumerateFiles(string dir, int curren`
`113`	`118`	`{`
`114`	`119`	`// Although IgnoreInaccessible is true by default,`
`115`	`120`	`// it only applies when you use the 3 parameter overload`
`116`		`- filePaths.AddRange(Directory.EnumerateFiles(dir, "*", _options).Select(f => new FilePath(f)));`
	`121`	`+ filePaths.AddRange(new DirectoryInfo(dir).EnumerateFiles("*", _options)`
	`122`	`+ .Where(fi => fi.Name.IsZipFile() \|\| _maxFileSize == 0 \|\| fi.Length <= _maxFileSize)`
	`123`	`+ .Select(fi => new FilePath(fi.FullName)));`
`117`	`124`	`}`
`118`	`125`	`catch`
`119`	`126`	`{`
`120`	`127`	`// IO exceptions e.g. directory was removed during enumeration`
`121`	`128`	`}`
`122`	`129`
`123`		`- yield return filePaths;`
	`130`	`+ yield return filePaths.NotZippedFiles();`
`124`	`131`
`125`	`132`	`// Any direcotry path exception has already been handled above`
`126`	`133`	`foreach (var subDir in Directory.EnumerateDirectories(dir, "*", _options))`
`127`	`134`	`{`
`128`		`- foreach (var subFiles in EnumerateFiles(subDir, currentDepth - 1))`
`129`		`- {`
`130`		`- yield return subFiles;`
`131`		`- }`
	`135`	`+ yield return EnumerateFiles(subDir, currentDepth - 1).SelectMany(f => f);`
`132`	`136`	`}`
`133`	`137`
`134`	`138`	`if (_searchInZipFiles)`
`135`	`139`	`{`
`136`	`140`	`foreach (FilePath filePath in filePaths)`
`137`	`141`	`{`
`138`		`- yield return ZipFileWalker.GetZippedFiles(filePath);`
	`142`	`+ yield return _zipFileWalker.GetZippedFiles(filePath);`
`139`	`143`	`}`
`140`	`144`	`}`
`141`	`145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,12 +5,19 @@`
`5`	`5`
`6`	`6`	`namespace RegexFileSearcher`
`7`	`7`	`{`
`8`		`- public static class ZipFileWalker`
	`8`	`+ internal class ZipFileWalker`
`9`	`9`	`{`
`10`		`- public static IEnumerable<FilePath> GetZippedFiles(FilePath filePath)`
	`10`	`+ private readonly int _maxFileSize;`
	`11`	`+`
	`12`	`+ public ZipFileWalker(int maxFileSize)`
	`13`	`+ {`
	`14`	`+ _maxFileSize = maxFileSize;`
	`15`	`+ }`
	`16`	`+`
	`17`	`+ public IEnumerable<FilePath> GetZippedFiles(FilePath filePath)`
`11`	`18`	`{`
`12`	`19`	`var results = new List<FilePath>();`
`13`		`- if (!IsZipFile(filePath.Path))`
	`20`	`+ if (!filePath.Path.IsZipFile())`
`14`	`21`	`{`
`15`	`22`	`return results;`
`16`	`23`	`}`
`@@ -30,7 +37,7 @@ public static IEnumerable<FilePath> GetZippedFiles(FilePath filePath)`
`30`	`37`	`return results;`
`31`	`38`	`}`
`32`	`39`
`33`		`- private static IEnumerable<FilePath> GetCompressedFilesInner(FilePath parentFilePath, Stream zipStream)`
	`40`	`+ private IEnumerable<FilePath> GetCompressedFilesInner(FilePath parentFilePath, Stream zipStream)`
`34`	`41`	`{`
`35`	`42`	`var results = new List<FilePath>();`
`36`	`43`	`try`
`@@ -39,7 +46,7 @@ private static IEnumerable<FilePath> GetCompressedFilesInner(FilePath parentFile`
`39`	`46`	`foreach (ZipEntry zipEntry in GetZipEntries(zipFile))`
`40`	`47`	`{`
`41`	`48`	`string zipEntryName = zipEntry.Name;`
`42`		`- if (IsZipFile(zipEntryName))`
	`49`	`+ if (zipEntryName.IsZipFile())`
`43`	`50`	`{`
`44`	`51`	`Stream entryStream = null;`
`45`	`52`	`try`
`@@ -72,21 +79,15 @@ private static IEnumerable<FilePath> GetCompressedFilesInner(FilePath parentFile`
`72`	`79`	`return results;`
`73`	`80`	`}`
`74`	`81`
`75`		`- private static IEnumerable<ZipEntry> GetZipEntries(ZipFile zipFile)`
	`82`	`+ private IEnumerable<ZipEntry> GetZipEntries(ZipFile zipFile)`
`76`	`83`	`{`
`77`	`84`	`foreach (ZipEntry zipEntry in zipFile)`
`78`	`85`	`{`
`79`		`- if (zipEntry.IsFile)`
	`86`	`+ if (zipEntry.IsFile && (_maxFileSize == 0 \|\| zipEntry.Size <= _maxFileSize))`
`80`	`87`	`{`
`81`	`88`	`yield return zipEntry;`
`82`	`89`	`}`
`83`	`90`	`}`
`84`	`91`	`}`
`85`		`-`
`86`		`- private static bool IsZipFile(string fileName)`
`87`		`- {`
`88`		`- string extension = Path.GetExtension(fileName).ToLower();`
`89`		`- return extension == ".zip";`
`90`		`- }`
`91`	`92`	`}`
`92`	`93`	`}`