← Back to branch summary

~ubuntu-branches/ubuntu/wily/monodevelop/wily

« back to all changes in this revision

Viewing changes to src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring/RefactoringService.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2012-05-27 18:08:20 UTC
  • mfrom: (19.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20120527180820-fydl21qnbnfr8w2t
Tags: 3.0.2+dfsg-3
* [fcecfe7] Fix monodevelop-core-addins.pc.in to point to actual 
  installed location of assemblies.
* [26e1a07] DebSrc 3.0 does not support Quilt's -p parameter, so 
  manually adjust the path in the patch file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring/RefactoringService.cs
27
27
using System;
28
28
using System.Collections.Generic;
29
29
using Mono.Addins;
30
 
using MonoDevelop.Projects.CodeGeneration;
31
30
using MonoDevelop.Core;
32
 
using MonoDevelop.Projects.Dom.Parser;
33
31
using MonoDevelop.Ide.Gui;
34
 
using MonoDevelop.CodeGeneration;
35
 
using MonoDevelop.Projects.Dom;
36
32
using System.Linq;
37
33
using MonoDevelop.AnalysisCore;
38
 
using MonoDevelop.Inspection;
 
34
using ICSharpCode.NRefactory;
 
35
using System.Threading.Tasks;
 
36
using System.Threading;
 
37
using MonoDevelop.CodeActions;
 
38
using MonoDevelop.CodeIssues;
 
39
using Mono.TextEditor;
39
40
 
40
41
namespace MonoDevelop.Refactoring
41
42
{
42
 
        using MonoDevelop.ContextAction;
43
 
 
44
43
        public static class RefactoringService
45
44
        {
46
45
                static List<RefactoringOperation> refactorings = new List<RefactoringOperation>();
47
 
                static List<INRefactoryASTProvider> astProviders = new List<INRefactoryASTProvider>();
48
 
                static List<ICodeGenerator> codeGenerators = new List<ICodeGenerator>();
49
 
                static List<ContextActionAddinNode> contextActions = new List<ContextActionAddinNode> ();
50
 
                static List<InspectorAddinNode> inspectors = new List<InspectorAddinNode> ();
 
46
                static List<CodeActionProvider> contextActions = new List<CodeActionProvider> ();
 
47
                static List<CodeIssueProvider> inspectors = new List<CodeIssueProvider> ();
51
48
                
52
 
                public static IEnumerable<ContextActionAddinNode> ContextAddinNodes {
 
49
                public static IEnumerable<CodeActionProvider> ContextAddinNodes {
53
50
                        get {
54
51
                                return contextActions;
55
52
                        }
56
53
                } 
 
54
 
 
55
                public static void AddProvider (CodeActionProvider provider)
 
56
                {
 
57
                        contextActions.Add (provider);
 
58
                }
57
59
                
 
60
                public static void AddProvider (CodeIssueProvider provider)
 
61
                {
 
62
                        inspectors.Add (provider);
 
63
                }
 
64
 
 
65
                public static List<CodeIssueProvider> Inspectors {
 
66
                        get {
 
67
                                return inspectors;
 
68
                        }
 
69
                }
 
70
 
58
71
                static RefactoringService ()
59
72
                {
60
73
                        AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Refactoring/Refactorings", delegate(object sender, ExtensionNodeEventArgs args) {
68
81
                                }
69
82
                        });
70
83
 
71
 
                        AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Refactoring/ASTProvider", delegate(object sender, ExtensionNodeEventArgs args) {
 
84
                        
 
85
                        AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Refactoring/CodeActions", delegate(object sender, ExtensionNodeEventArgs args) {
72
86
                                switch (args.Change) {
73
87
                                case ExtensionChange.Add:
74
 
                                        astProviders.Add ((INRefactoryASTProvider)args.ExtensionObject);
 
88
                                        contextActions.Add (((CodeActionAddinNode)args.ExtensionNode).Action);
75
89
                                        break;
76
90
                                case ExtensionChange.Remove:
77
 
                                        astProviders.Remove ((INRefactoryASTProvider)args.ExtensionObject);
 
91
                                        contextActions.Remove (((CodeActionAddinNode)args.ExtensionNode).Action);
 
92
                                        break;
 
93
                                }
 
94
                        });
 
95
                        
 
96
                        AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Refactoring/CodeActionSource", delegate(object sender, ExtensionNodeEventArgs args) {
 
97
                                switch (args.Change) {
 
98
                                case ExtensionChange.Add:
 
99
                                        contextActions.AddRange (((ICodeActionProviderSource)args.ExtensionObject).GetProviders ());
78
100
                                        break;
79
101
                                }
80
102
                        });
81
103
 
82
 
                        AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Refactoring/CodeGenerators", delegate(object sender, ExtensionNodeEventArgs args) {
 
104
                        AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Refactoring/CodeIssues", delegate(object sender, ExtensionNodeEventArgs args) {
83
105
                                switch (args.Change) {
84
106
                                case ExtensionChange.Add:
85
 
                                        codeGenerators.Add ((ICodeGenerator)args.ExtensionObject);
 
107
                                        inspectors.Add (((CodeIssueAddinNode)args.ExtensionNode).Inspector);
86
108
                                        break;
87
109
                                case ExtensionChange.Remove:
88
 
                                        codeGenerators.Remove ((ICodeGenerator)args.ExtensionObject);
 
110
                                        inspectors.Remove (((CodeIssueAddinNode)args.ExtensionNode).Inspector);
89
111
                                        break;
90
112
                                }
91
113
                        });
92
114
                        
93
 
//                      AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Refactoring/ContextActions", delegate(object sender, ExtensionNodeEventArgs args) {
94
 
//                              switch (args.Change) {
95
 
//                              case ExtensionChange.Add:
96
 
//                                      contextActions.Add ((ContextActionAddinNode)args.ExtensionNode);
97
 
//                                      break;
98
 
//                              case ExtensionChange.Remove:
99
 
//                                      contextActions.Remove ((ContextActionAddinNode)args.ExtensionNode);
100
 
//                                      break;
101
 
//                              }
102
 
//                      });
103
 
//                      
104
 
                        AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Refactoring/Inspectors", delegate(object sender, ExtensionNodeEventArgs args) {
 
115
                AddinManager.AddExtensionNodeHandler ("/MonoDevelop/Refactoring/CodeIssueSource", delegate(object sender, ExtensionNodeEventArgs args) {
105
116
                                switch (args.Change) {
106
117
                                case ExtensionChange.Add:
107
 
                                        inspectors.Add ((InspectorAddinNode)args.ExtensionNode);
108
 
                                        break;
109
 
                                case ExtensionChange.Remove:
110
 
                                        inspectors.Remove ((InspectorAddinNode)args.ExtensionNode);
 
118
                                        inspectors.AddRange (((ICodeIssueProviderSource)args.ExtensionObject).GetProviders ());
111
119
                                        break;
112
120
                                }
113
121
                        });
120
128
                        }
121
129
                }
122
130
                
123
 
                public static IEnumerable<ICodeGenerator> CodeGenerators {
124
 
                        get {
125
 
                                return codeGenerators;
126
 
                        }
127
 
                }
128
 
                
129
131
                class RenameHandler 
130
132
                {
131
133
                        IEnumerable<Change> changes;
147
149
                        }
148
150
                }
149
151
                
150
 
                public static void AcceptChanges (IProgressMonitor monitor, ProjectDom dom, List<Change> changes)
 
152
                public static void AcceptChanges (IProgressMonitor monitor, List<Change> changes)
151
153
                {
152
 
                        AcceptChanges (monitor, dom, changes, MonoDevelop.Ide.TextFileProvider.Instance);
 
154
                        AcceptChanges (monitor, changes, MonoDevelop.Ide.TextFileProvider.Instance);
153
155
                }
154
156
                
155
 
                public static void AcceptChanges (IProgressMonitor monitor, ProjectDom dom, List<Change> changes, MonoDevelop.Projects.Text.ITextFileProvider fileProvider)
 
157
                public static void AcceptChanges (IProgressMonitor monitor, List<Change> changes, MonoDevelop.Projects.Text.ITextFileProvider fileProvider)
156
158
                {
157
 
                        var rctx = new RefactorerContext (dom, fileProvider, null);
 
159
                        var rctx = new RefactoringOptions (null);
158
160
                        var handler = new RenameHandler (changes);
159
161
                        FileService.FileRenamed += handler.FileRename;
160
162
                        for (int i = 0; i < changes.Count; i++) {
182
184
                        TextReplaceChange.FinishRefactoringOperation ();
183
185
                }
184
186
                
185
 
                public static INRefactoryASTProvider GetASTProvider (string mimeType)
186
 
                {
187
 
                        foreach (INRefactoryASTProvider provider in astProviders) {
188
 
                                if (provider.CanGenerateASTFrom (mimeType)) {
189
 
                                        return provider;
 
187
                public static IEnumerable<CodeIssueProvider> GetInspectors (string mimeType)
 
188
                {
 
189
                        return inspectors.Where (i => i.MimeType == mimeType);
 
190
                }
 
191
 
 
192
                public static Task<IEnumerable<MonoDevelop.CodeActions.CodeAction>> GetValidActions (MonoDevelop.Ide.Gui.Document doc, TextLocation loc, CancellationToken cancellationToken = default (CancellationToken))
 
193
                {
 
194
                        return Task.Factory.StartNew (delegate {
 
195
                                var result = new List<MonoDevelop.CodeActions.CodeAction> ();
 
196
                                try {
 
197
                                        var editor = doc.Editor;
 
198
                                        if (editor != null) {
 
199
                                                string disabledNodes = PropertyService.Get ("ContextActions." + editor.Document.MimeType, "") ?? "";
 
200
                                                foreach (var provider in contextActions.Where (fix => disabledNodes.IndexOf (fix.IdString) < 0)) {
 
201
                                                        try {
 
202
                                                                result.AddRange (provider.GetActions (doc, loc, cancellationToken));
 
203
                                                        } catch (Exception ex) {
 
204
                                                                LoggingService.LogError ("Error in context action provider " + provider.Title, ex);
 
205
                                                        }
 
206
                                                }
 
207
                                        }
 
208
                                } catch (Exception ex) {
 
209
                                        LoggingService.LogError ("Error in analysis service", ex);
190
210
                                }
191
 
                        }
192
 
                        return null;
193
 
                }
194
 
                
195
 
                public static IEnumerable<InspectorAddinNode> GetInspectors (string mimeTye)
196
 
                {
197
 
                        return inspectors.Where (i => i.MimeType == mimeTye);
198
 
                }
199
 
                
200
 
                public static void QueueQuickFixAnalysis (MonoDevelop.Ide.Gui.Document doc, DomLocation loc, Action<List<ContextAction>> callback)
 
211
                                return (IEnumerable<MonoDevelop.CodeActions.CodeAction>)result;
 
212
                        }, cancellationToken);
 
213
                }
 
214
 
 
215
                public static void QueueQuickFixAnalysis (MonoDevelop.Ide.Gui.Document doc, TextLocation loc, Action<List<MonoDevelop.CodeActions.CodeAction>> callback)
201
216
                {
202
217
                        System.Threading.ThreadPool.QueueUserWorkItem (delegate {
203
218
                                try {
204
 
                                        string disabledNodes = PropertyService.Get ("ContextActions." + doc.Editor.Document.MimeType, "") ?? "";
205
 
                                        
206
 
                                        var availableFixes = new List<ContextAction> (contextActions.Where (fix => disabledNodes.IndexOf (fix.Type.FullName) < 0 && fix.Action.IsValid (doc, loc)).Select (fix => fix.Action));
 
219
                                        var result = new List<MonoDevelop.CodeActions.CodeAction> ();
 
220
 
207
221
                                        var ext = doc.GetContent<MonoDevelop.AnalysisCore.Gui.ResultsEditorExtension> ();
208
222
                                        if (ext != null) {
209
 
                                                foreach (var result in ext.GetResultsAtOffset (doc.Editor.LocationToOffset (loc.Line, loc.Column))) {
210
 
                                                        var fresult = result as FixableResult;
 
223
                                                foreach (var r in ext.GetResultsAtOffset (doc.Editor.LocationToOffset (loc)).OrderBy (r => r.Level)) {
 
224
                                                        var fresult = r as FixableResult;
211
225
                                                        if (fresult == null)
212
226
                                                                continue;
213
227
                                                        foreach (var action in FixOperationsHandler.GetActions (doc, fresult)) {
214
 
                                                                availableFixes.Add (new AnalysisContextAction (result, action));
 
228
                                                                result.Add (new AnalysisContextActionProvider.AnalysisCodeAction (action, r));
215
229
                                                        }
216
230
                                                }
217
231
                                        }
218
 
                                        
219
 
                                        callback (availableFixes);
 
232
                                        result.AddRange (GetValidActions (doc, loc).Result);
 
233
                                        callback (result);
220
234
                                } catch (Exception ex) {
221
235
                                        LoggingService.LogError ("Error in analysis service", ex);
222
236
                                }
223
237
                        });
224
238
                }       
 
239
 
 
240
                public static DocumentLocation GetCorrectResolveLocation (Document doc, DocumentLocation location)
 
241
                {
 
242
                        if (doc == null)
 
243
                                throw new ArgumentNullException ("doc");
 
244
                        var editor = doc.Editor;
 
245
                        if (editor == null || location.Column == 1)
 
246
                                return location;
 
247
 
 
248
                        var line = editor.GetLine (location.Line);
 
249
                        if (line == null || location.Column >= line.Length)
 
250
                                return location;
 
251
 
 
252
                        int offset = editor.LocationToOffset (location);
 
253
                        if (offset > 0 && !char.IsLetterOrDigit (doc.Editor.GetCharAt (offset)) && char.IsLetterOrDigit (doc.Editor.GetCharAt (offset - 1)))
 
254
                                return new DocumentLocation (location.Line, location.Column - 1);
 
255
                        return location;
 
256
                }
225
257
        }
226
258
}