← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to src/core/MonoDevelop.Ide/MonoDevelop.Ide.FindInFiles/Scope.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/MonoDevelop.Ide/MonoDevelop.Ide.FindInFiles/Scope.cs
31
31
using MonoDevelop.Projects;
32
32
using MonoDevelop.Ide.Gui;
33
33
using MonoDevelop.Core;
 
34
using System.Security.Permissions;
 
35
using System.Security;
34
36
 
35
37
 
36
38
namespace MonoDevelop.Ide.FindInFiles
104
106
                public override IEnumerable<FileProvider> GetFiles (IProgressMonitor monitor, FilterOptions filterOptions)
105
107
                {
106
108
                        if (IdeApp.Workspace.IsOpen) {
 
109
                                var alreadyVisited = new HashSet<string> ();
107
110
                                foreach (Project project in IdeApp.Workspace.GetAllProjects ()) {
108
111
                                        monitor.Log.WriteLine (GettextCatalog.GetString ("Looking in project '{0}'", project.Name));
109
112
                                        foreach (ProjectFile file in project.Files.Where (f => filterOptions.NameMatches (f.Name) && File.Exists (f.Name))) {
110
 
                                                if (!IncludeBinaryFiles && !DesktopService.GetMimeTypeIsText (DesktopService.GetMimeTypeForUri (file.Name)))
 
113
                                                if (!IncludeBinaryFiles && !DesktopService.GetFileIsText (file.FilePath))
 
114
                                                                continue;
 
115
                                                if (alreadyVisited.Contains (file.Name))
111
116
                                                        continue;
 
117
                                                alreadyVisited.Add (file.Name);
112
118
                                                yield return new FileProvider (file.Name, project);
113
119
                                        }
114
120
                                }
144
150
                {
145
151
                        if (IdeApp.Workspace.IsOpen) {
146
152
                                monitor.Log.WriteLine (GettextCatalog.GetString ("Looking in project '{0}'", project.Name));
 
153
                                var alreadyVisited = new HashSet<string> ();
147
154
                                foreach (ProjectFile file in project.Files.Where (f => filterOptions.NameMatches (f.Name) && File.Exists (f.Name))) {
148
 
                                        if (!IncludeBinaryFiles && !DesktopService.GetMimeTypeIsText (DesktopService.GetMimeTypeForUri (file.Name)))
149
 
                                                continue;
 
155
                                        if (!IncludeBinaryFiles && !DesktopService.GetFileIsText (file.Name))
 
156
                                                continue;
 
157
 
 
158
                                        if (alreadyVisited.Contains (file.Name))
 
159
                                                continue;
 
160
                                        alreadyVisited.Add (file.Name);
150
161
                                        yield return new FileProvider (file.Name, project);
151
162
                                }
152
163
                        }
211
222
                {
212
223
                        if (monitor != null)
213
224
                                monitor.Log.WriteLine (GettextCatalog.GetString ("Looking in '{0}'", path));
214
 
                        foreach (string fileMask in filterOptions.FileMask.Split (',', ';')) {
215
 
                                string[] files;
 
225
                        var directoryStack = new Stack<string> ();
 
226
                        directoryStack.Push (path);
 
227
 
 
228
                        while (directoryStack.Count > 0) {
 
229
                                var curPath = directoryStack.Pop ();
 
230
 
216
231
                                try {
217
 
                                        files = Directory.GetFiles (path, fileMask, recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
 
232
                                        var readPermission = new FileIOPermission(FileIOPermissionAccess.Read, curPath);
 
233
                                        readPermission.Demand ();
218
234
                                } catch (Exception e) {
219
 
                                        LoggingService.LogError ("Can't access path " + path, e);
 
235
                                        LoggingService.LogError ("Can't access path " + curPath, e);
220
236
                                        yield break;
221
237
                                }
222
 
                                
223
 
                                foreach (string fileName in files) {
224
 
                                        if (fileName.StartsWith (".") && !IncludeHiddenFiles)
225
 
                                                continue;
226
 
                                        if (!IncludeBinaryFiles && !DesktopService.GetMimeTypeIsText (DesktopService.GetMimeTypeForUri (fileName))) 
 
238
 
 
239
                                foreach (string fileName in Directory.EnumerateFiles (curPath, "*")) {
 
240
                                        if (!IncludeHiddenFiles) {
 
241
                                                if (Platform.IsWindows) {
 
242
                                                        var attr = File.GetAttributes (fileName);
 
243
                                                        if (attr.HasFlag (FileAttributes.Hidden))
 
244
                                                                continue;
 
245
                                                }
 
246
                                                if (Path.GetFileName (fileName).StartsWith (".", StringComparison.Ordinal))
 
247
                                                        continue;
 
248
                                        }
 
249
 
 
250
                                        if (!IncludeBinaryFiles && !DesktopService.GetFileIsText (fileName))
227
251
                                                continue;
228
252
                                        yield return fileName;
229
253
                                }
 
254
 
 
255
                                if (recurse) {
 
256
                                        foreach (string directoryName in Directory.EnumerateDirectories (curPath)) {
 
257
                                                if (!IncludeHiddenFiles) {
 
258
                                                        if (Platform.IsWindows) {
 
259
                                                                var attr = File.GetAttributes (directoryName);
 
260
                                                                if (attr.HasFlag (FileAttributes.Hidden))
 
261
                                                                        continue;
 
262
                                                        }
 
263
                                                        if (Path.GetFileName (directoryName).StartsWith (".", StringComparison.Ordinal))
 
264
                                                                continue;
 
265
                                                }
 
266
                                                directoryStack.Push (directoryName);
 
267
                                        }
 
268
                                }
 
269
 
230
270
                        }
231
271
                }
232
272