RegExContentProposalProvider


1   /*******************************************************************************
2    * Copyright (c) 2006 IBM Corporation and others.
3    * All rights reserved. This program and the accompanying materials
4    * are made available under the terms of the Eclipse Public License v1.0
5    * which accompanies this distribution, and is available at
6    * http://www.eclipse.org/legal/epl-v10.html
7    *
8    * Contributors:
9    *     IBM Corporation - initial API and implementation
10   *******************************************************************************/
11  
12  package org.eclipse.ui.texteditor;
13  
14  import java.util.ArrayList  ;
15  
16  import org.eclipse.jface.fieldassist.IContentProposal;
17  import org.eclipse.jface.fieldassist.IContentProposalProvider;
18  
19  /**
20   * Content assist proposal provider for regular expressions.
21   * <p>
22   * Note: Replaces <code>RegExContentAssistProcessor</code> which was introduced in 3.0.
23   * </p>
24   *
25   * @since 3.2
26   */
27  final class RegExContentProposalProvider implements IContentProposalProvider {
28  
29      
30      /**
31       * Proposal computer.
32       */
33      private static class ProposalComputer {
34  
35          private static class Proposal implements IContentProposal {
36              
37              private String   fContent;
38              private String   fLabel;
39              private String   fDescription;
40              private int fCursorPosition;
41              
42              Proposal(String   content, String   label, String   description, int cursorPosition) {
43                  fContent= content;
44                  fLabel= label;
45                  fDescription= description;
46                  fCursorPosition= cursorPosition;
47              }
48              
49              public String   getContent() {
50                  return fContent;
51              }
52              
53              public String   getLabel() {
54                  return fLabel;
55              }
56              
57              public String   getDescription() {
58                  return fDescription;
59              }
60              
61              public int getCursorPosition() {
62                  return fCursorPosition;
63              }
64          }
65          
66  
67          /**
68           * The whole regular expression.
69           */
70          private final String   fExpression;
71          /**
72           * The document offset.
73           */
74          private final int fDocumentOffset;
75          /**
76           * The high-priority proposals.
77           */
78          private final ArrayList   fPriorityProposals;
79          /**
80           * The low-priority proposals.
81           */
82          private final ArrayList   fProposals;
83          /**
84           * <code>true</code> iff <code>fExpression</code> ends with an open escape.
85           */
86          private final boolean fIsEscape;
87  
88          /**
89           * Creates a new Proposal Computer.
90           * @param contents the contents of the subject control
91           * @param position the cursor position
92           */
93          public ProposalComputer(String   contents, int position) {
94              fExpression= contents;
95              fDocumentOffset= position;
96              fPriorityProposals= new ArrayList  ();
97              fProposals= new ArrayList  ();
98              
99              boolean isEscape= false;
100             esc: for (int i= position - 1; i >= 0; i--) {
101                 if (fExpression.charAt(i) == '\\')
102                     isEscape= !isEscape;
103                 else
104                     break esc;
105             }
106             fIsEscape= isEscape;
107         }
108 
109         /**
110          * Computes applicable proposals for the find field.
111          * @return the proposals
112          */
113         public IContentProposal[] computeFindProposals() {
114             //characters
115             addBsProposal("\\\\", RegExMessages.displayString_bs_bs, RegExMessages.additionalInfo_bs_bs); //$NON-NLS-1$
116             addBracketProposal("\\0", 2, RegExMessages.displayString_bs_0, RegExMessages.additionalInfo_bs_0); //$NON-NLS-1$
117             addBracketProposal("\\x", 2, RegExMessages.displayString_bs_x, RegExMessages.additionalInfo_bs_x); //$NON-NLS-1$
118             addBracketProposal("\\u", 2, RegExMessages.displayString_bs_u, RegExMessages.additionalInfo_bs_u); //$NON-NLS-1$
119             addBsProposal("\\t", RegExMessages.displayString_bs_t, RegExMessages.additionalInfo_bs_t); //$NON-NLS-1$
120             addBsProposal("\\n", RegExMessages.displayString_bs_n, RegExMessages.additionalInfo_bs_n); //$NON-NLS-1$
121             addBsProposal("\\r", RegExMessages.displayString_bs_r, RegExMessages.additionalInfo_bs_r); //$NON-NLS-1$
122             addBsProposal("\\f", RegExMessages.displayString_bs_f, RegExMessages.additionalInfo_bs_f); //$NON-NLS-1$
123             addBsProposal("\\a", RegExMessages.displayString_bs_a, RegExMessages.additionalInfo_bs_a); //$NON-NLS-1$
124             addBsProposal("\\e", RegExMessages.displayString_bs_e, RegExMessages.additionalInfo_bs_e); //$NON-NLS-1$
125             addBsProposal("\\c", RegExMessages.displayString_bs_c, RegExMessages.additionalInfo_bs_c); //$NON-NLS-1$
126             
127             if (! fIsEscape)
128                 addBracketProposal(".", 1, RegExMessages.displayString_dot, RegExMessages.additionalInfo_dot); //$NON-NLS-1$
129             addBsProposal("\\d", RegExMessages.displayString_bs_d, RegExMessages.additionalInfo_bs_d); //$NON-NLS-1$
130             addBsProposal("\\D", RegExMessages.displayString_bs_D, RegExMessages.additionalInfo_bs_D); //$NON-NLS-1$
131             addBsProposal("\\s", RegExMessages.displayString_bs_s, RegExMessages.additionalInfo_bs_s); //$NON-NLS-1$
132             addBsProposal("\\S", RegExMessages.displayString_bs_S, RegExMessages.additionalInfo_bs_S); //$NON-NLS-1$
133             addBsProposal("\\w", RegExMessages.displayString_bs_w, RegExMessages.additionalInfo_bs_w); //$NON-NLS-1$
134             addBsProposal("\\W", RegExMessages.displayString_bs_W, RegExMessages.additionalInfo_bs_W); //$NON-NLS-1$
135             
136             // back reference
137             addBsProposal("\\", RegExMessages.displayString_bs_i, RegExMessages.additionalInfo_bs_i); //$NON-NLS-1$
138             
139             //quoting
140             addBsProposal("\\", RegExMessages.displayString_bs, RegExMessages.additionalInfo_bs); //$NON-NLS-1$
141             addBsProposal("\\Q", RegExMessages.displayString_bs_Q, RegExMessages.additionalInfo_bs_Q); //$NON-NLS-1$
142             addBsProposal("\\E", RegExMessages.displayString_bs_E, RegExMessages.additionalInfo_bs_E); //$NON-NLS-1$
143             
144             //character sets
145             if (! fIsEscape) {
146                 addBracketProposal("[]", 1, RegExMessages.displayString_set, RegExMessages.additionalInfo_set); //$NON-NLS-1$
147                 addBracketProposal("[^]", 2, RegExMessages.displayString_setExcl, RegExMessages.additionalInfo_setExcl); //$NON-NLS-1$
148                 addBracketProposal("[-]", 1, RegExMessages.displayString_setRange, RegExMessages.additionalInfo_setRange); //$NON-NLS-1$
149                 addProposal("&&", RegExMessages.displayString_setInter, RegExMessages.additionalInfo_setInter); //$NON-NLS-1$
150             }
151             if (! fIsEscape && fDocumentOffset > 0 && fExpression.charAt(fDocumentOffset - 1) == '\\') {
152                 addProposal("\\p{}", 3, RegExMessages.displayString_posix, RegExMessages.additionalInfo_posix); //$NON-NLS-1$
153                 addProposal("\\P{}", 3, RegExMessages.displayString_posixNot, RegExMessages.additionalInfo_posixNot); //$NON-NLS-1$
154             } else {
155                 addBracketProposal("\\p{}", 3, RegExMessages.displayString_posix, RegExMessages.additionalInfo_posix); //$NON-NLS-1$
156                 addBracketProposal("\\P{}", 3, RegExMessages.displayString_posixNot, RegExMessages.additionalInfo_posixNot); //$NON-NLS-1$
157             }
158             
159 //          addBsProposal("\\p{Lower}", RegExMessages.displayString_bs_p{Lower}, RegExMessages.additionalInfo_bs_p{Lower}); //$NON-NLS-1$
160 //          addBsProposal("\\p{Upper}", RegExMessages.displayString_bs_p{Upper}, RegExMessages.additionalInfo_bs_p{Upper}); //$NON-NLS-1$
161 //          addBsProposal("\\p{ASCII}", RegExMessages.displayString_bs_p{ASCII}, RegExMessages.additionalInfo_bs_p{ASCII}); //$NON-NLS-1$
162 //          addBsProposal("\\p{Alpha}", RegExMessages.displayString_bs_p{Alpha}, RegExMessages.additionalInfo_bs_p{Alpha}); //$NON-NLS-1$
163 //          addBsProposal("\\p{Digit}", RegExMessages.displayString_bs_p{Digit}, RegExMessages.additionalInfo_bs_p{Digit}); //$NON-NLS-1$
164 //          addBsProposal("\\p{Alnum}", RegExMessages.displayString_bs_p{Alnum}, RegExMessages.additionalInfo_bs_p{Alnum}); //$NON-NLS-1$
165 //          addBsProposal("\\p{Punct}", RegExMessages.displayString_bs_p{Punct}, RegExMessages.additionalInfo_bs_p{Punct}); //$NON-NLS-1$
166 //          addBsProposal("\\p{Graph}", RegExMessages.displayString_bs_p{Graph}, RegExMessages.additionalInfo_bs_p{Graph}); //$NON-NLS-1$
167 //          addBsProposal("\\p{Print}", RegExMessages.displayString_bs_p{Print}, RegExMessages.additionalInfo_bs_p{Print}); //$NON-NLS-1$
168 //          addBsProposal("\\p{Blank}", RegExMessages.displayString_bs_p{Blank}, RegExMessages.additionalInfo_bs_p{Blank}); //$NON-NLS-1$
169 //          addBsProposal("\\p{Cntrl}", RegExMessages.displayString_bs_p{Cntrl}, RegExMessages.additionalInfo_bs_p{Cntrl}); //$NON-NLS-1$
170 //          addBsProposal("\\p{XDigit}", RegExMessages.displayString_bs_p{XDigit}, RegExMessages.additionalInfo_bs_p{XDigit}); //$NON-NLS-1$
171 //          addBsProposal("\\p{Space}", RegExMessages.displayString_bs_p{Space}, RegExMessages.additionalInfo_bs_p{Space}); //$NON-NLS-1$
172 //
173 //          addBsProposal("\\p{InGreek}", RegExMessages.displayString_bs_p{InGreek}, RegExMessages.additionalInfo_bs_p{InGreek}); //$NON-NLS-1$
174 //          addBsProposal("\\p{Lu}", RegExMessages.displayString_bs_p{Lu}, RegExMessages.additionalInfo_bs_p{Lu}); //$NON-NLS-1$
175 //          addBsProposal("\\p{Sc}", RegExMessages.displayString_bs_p{Sc}, RegExMessages.additionalInfo_bs_p{Sc}); //$NON-NLS-1$
176 //          addBsProposal("\\P{InGreek}", RegExMessages.displayString_bs_P{InGreek}, RegExMessages.additionalInfo_bs_P{InGreek}); //$NON-NLS-1$
177             
178             //boundary matchers
179             if (fDocumentOffset == 0) {
180                 addPriorityProposal("^", RegExMessages.displayString_start, RegExMessages.additionalInfo_start); //$NON-NLS-1$
181             } else if (fDocumentOffset == 1 && fExpression.charAt(0) == '^') {
182                 addBracketProposal("^", 1, RegExMessages.displayString_start, RegExMessages.additionalInfo_start); //$NON-NLS-1$
183             }
184             if (fDocumentOffset == fExpression.length()) {
185                 addProposal("$", RegExMessages.displayString_end, RegExMessages.additionalInfo_end); //$NON-NLS-1$
186             }
187             addBsProposal("\\b", RegExMessages.displayString_bs_b, RegExMessages.additionalInfo_bs_b); //$NON-NLS-1$
188             addBsProposal("\\B", RegExMessages.displayString_bs_B, RegExMessages.additionalInfo_bs_B); //$NON-NLS-1$
189             addBsProposal("\\A", RegExMessages.displayString_bs_A, RegExMessages.additionalInfo_bs_A); //$NON-NLS-1$
190             addBsProposal("\\G", RegExMessages.displayString_bs_G, RegExMessages.additionalInfo_bs_G); //$NON-NLS-1$
191             addBsProposal("\\Z", RegExMessages.displayString_bs_Z, RegExMessages.additionalInfo_bs_Z); //$NON-NLS-1$
192             addBsProposal("\\z", RegExMessages.displayString_bs_z, RegExMessages.additionalInfo_bs_z); //$NON-NLS-1$
193             
194             if (! fIsEscape) {
195                 //capturing groups
196                 addBracketProposal("()", 1, RegExMessages.displayString_group, RegExMessages.additionalInfo_group); //$NON-NLS-1$
197                 
198                 //flags
199                 addBracketProposal("(?)", 2, RegExMessages.displayString_flag, RegExMessages.additionalInfo_flag); //$NON-NLS-1$
200                 addBracketProposal("(?:)", 3, RegExMessages.displayString_flagExpr, RegExMessages.additionalInfo_flagExpr); //$NON-NLS-1$
201             
202                 //non-capturing group
203                 addBracketProposal("(?:)", 3, RegExMessages.displayString_nonCap, RegExMessages.additionalInfo_nonCap); //$NON-NLS-1$
204                 addBracketProposal("(?>)", 3, RegExMessages.displayString_atomicCap, RegExMessages.additionalInfo_atomicCap); //$NON-NLS-1$
205                 
206                 //lookaraound
207                 addBracketProposal("(?=)", 3, RegExMessages.displayString_posLookahead, RegExMessages.additionalInfo_posLookahead); //$NON-NLS-1$
208                 addBracketProposal("(?!)", 3, RegExMessages.displayString_negLookahead, RegExMessages.additionalInfo_negLookahead); //$NON-NLS-1$
209                 addBracketProposal("(?<=)", 4, RegExMessages.displayString_posLookbehind, RegExMessages.additionalInfo_posLookbehind); //$NON-NLS-1$
210                 addBracketProposal("(?<!)", 4, RegExMessages.displayString_negLookbehind, RegExMessages.additionalInfo_negLookbehind); //$NON-NLS-1$
211                 
212                 //greedy quantifiers
213                 addBracketProposal("?", 1, RegExMessages.displayString_quest, RegExMessages.additionalInfo_quest); //$NON-NLS-1$
214                 addBracketProposal("*", 1, RegExMessages.displayString_star, RegExMessages.additionalInfo_star); //$NON-NLS-1$
215                 addBracketProposal("+", 1, RegExMessages.displayString_plus, RegExMessages.additionalInfo_plus); //$NON-NLS-1$
216                 addBracketProposal("{}", 1, RegExMessages.displayString_exact, RegExMessages.additionalInfo_exact); //$NON-NLS-1$
217                 addBracketProposal("{,}", 1, RegExMessages.displayString_least, RegExMessages.additionalInfo_least); //$NON-NLS-1$
218                 addBracketProposal("{,}", 1, RegExMessages.displayString_count, RegExMessages.additionalInfo_count); //$NON-NLS-1$
219                 
220                 //lazy quantifiers
221                 addBracketProposal("??", 1, RegExMessages.displayString_questLazy, RegExMessages.additionalInfo_questLazy); //$NON-NLS-1$
222                 addBracketProposal("*?", 1, RegExMessages.displayString_starLazy, RegExMessages.additionalInfo_starLazy); //$NON-NLS-1$
223                 addBracketProposal("+?", 1, RegExMessages.displayString_plusLazy, RegExMessages.additionalInfo_plusLazy); //$NON-NLS-1$
224                 addBracketProposal("{}?", 1, RegExMessages.displayString_exactLazy, RegExMessages.additionalInfo_exactLazy); //$NON-NLS-1$
225                 addBracketProposal("{,}?", 1, RegExMessages.displayString_leastLazy, RegExMessages.additionalInfo_leastLazy); //$NON-NLS-1$
226                 addBracketProposal("{,}?", 1, RegExMessages.displayString_countLazy, RegExMessages.additionalInfo_countLazy); //$NON-NLS-1$
227                 
228                 //possessive quantifiers
229                 addBracketProposal("?+", 1, RegExMessages.displayString_questPoss, RegExMessages.additionalInfo_questPoss); //$NON-NLS-1$
230                 addBracketProposal("*+", 1, RegExMessages.displayString_starPoss, RegExMessages.additionalInfo_starPoss); //$NON-NLS-1$
231                 addBracketProposal("++", 1, RegExMessages.displayString_plusPoss, RegExMessages.additionalInfo_plusPoss); //$NON-NLS-1$
232                 addBracketProposal("{}+", 1, RegExMessages.displayString_exactPoss, RegExMessages.additionalInfo_exactPoss); //$NON-NLS-1$
233                 addBracketProposal("{,}+", 1, RegExMessages.displayString_leastPoss, RegExMessages.additionalInfo_leastPoss); //$NON-NLS-1$
234                 addBracketProposal("{,}+", 1, RegExMessages.displayString_countPoss, RegExMessages.additionalInfo_countPoss); //$NON-NLS-1$
235                 
236                 //alternative
237                 addBracketProposal("|", 1, RegExMessages.displayString_alt, RegExMessages.additionalInfo_alt); //$NON-NLS-1$
238             }
239             
240             fPriorityProposals.addAll(fProposals);
241             return (IContentProposal[]) fPriorityProposals.toArray(new IContentProposal[fProposals.size()]);
242         }
243 
244         /**
245          * Computes applicable proposals for the replace field.
246          * @return the proposals
247          */
248         public IContentProposal[] computeReplaceProposals() {
249             if (fDocumentOffset > 0 && '$' == fExpression.charAt(fDocumentOffset - 1)) {
250                 addProposal("", RegExMessages.displayString_dollar, RegExMessages.additionalInfo_dollar); //$NON-NLS-1$
251             } else {
252                 addProposal("$", RegExMessages.displayString_dollar, RegExMessages.additionalInfo_dollar); //$NON-NLS-1$
253                 addBsProposal("\\", RegExMessages.displayString_replace_bs, RegExMessages.additionalInfo_replace_bs); //$NON-NLS-1$
254                 addProposal("\t", RegExMessages.displayString_tab, RegExMessages.additionalInfo_tab); //$NON-NLS-1$
255             }
256             return (IContentProposal[]) fProposals.toArray(new IContentProposal[fProposals.size()]);
257         }
258         
259         /**
260          * Adds a proposal.
261          * 
262          * @param proposal the string to be inserted
263          * @param displayString the proposal's label
264          * @param additionalInfo the additional information
265          */
266         private void addProposal(String   proposal, String   displayString, String   additionalInfo) {
267             fProposals.add(new Proposal(proposal, displayString, additionalInfo, proposal.length()));
268         }
269 
270         /**
271          * Adds a proposal.
272          * 
273          * @param proposal the string to be inserted
274          * @param cursorPosition the cursor position after insertion,
275          *      relative to the start of the proposal
276          * @param displayString the proposal's label
277          * @param additionalInfo the additional information
278          */
279         private void addProposal(String   proposal, int cursorPosition, String   displayString, String   additionalInfo) {
280             fProposals.add(new Proposal(proposal, displayString, additionalInfo, cursorPosition));
281         }
282 
283         /**
284          * Adds a proposal to the priority proposals list.
285          * 
286          * @param proposal the string to be inserted
287          * @param displayString the proposal's label
288          * @param additionalInfo the additional information
289          */
290         private void addPriorityProposal(String   proposal, String   displayString, String   additionalInfo) {
291             fPriorityProposals.add(new Proposal(proposal, displayString, additionalInfo, proposal.length()));
292         }
293         
294         /**
295          * Adds a proposal. Ensures that existing pre- and postfixes are not duplicated.
296          * 
297          * @param proposal the string to be inserted
298          * @param cursorPosition the cursor position after insertion,
299          *      relative to the start of the proposal
300          * @param displayString the proposal's label
301          * @param additionalInfo the additional information
302          */
303         private void addBracketProposal(String   proposal, int cursorPosition, String   displayString, String   additionalInfo) {
304             String   prolog= fExpression.substring(0, fDocumentOffset);
305             if (! fIsEscape && prolog.endsWith("\\") && proposal.startsWith("\\")) { //$NON-NLS-1$//$NON-NLS-2$
306                 fProposals.add(new Proposal(proposal, displayString, additionalInfo, cursorPosition));
307                 return;
308             }
309             for (int i= 1; i <= cursorPosition; i++) {
310                 String   prefix= proposal.substring(0, i);
311                 if (prolog.endsWith(prefix)) {
312                     String   postfix= proposal.substring(cursorPosition);
313                     String   epilog= fExpression.substring(fDocumentOffset);
314                     if (epilog.startsWith(postfix)) {
315                         fPriorityProposals.add(new Proposal(proposal.substring(i, cursorPosition), displayString, additionalInfo, cursorPosition-i));
316                     } else {
317                         fPriorityProposals.add(new Proposal(proposal.substring(i), displayString, additionalInfo, cursorPosition-i));
318                     }
319                     return;
320                 }
321             }
322             fProposals.add(new Proposal(proposal, displayString, additionalInfo, cursorPosition));
323         }
324 
325         /**
326          * Adds a proposal that starts with a backslash.
327          * Ensures that the backslash is not repeated if already typed.
328          * 
329          * @param proposal the string to be inserted
330          * @param displayString the proposal's label
331          * @param additionalInfo the additional information
332          */
333         private void addBsProposal(String   proposal, String   displayString, String   additionalInfo) {
334             String   prolog= fExpression.substring(0, fDocumentOffset);
335             int position= proposal.length();
336             // If the string already contains the backslash, do not include in the proposal
337             if (prolog.endsWith("\\")) { //$NON-NLS-1$
338                 position--;
339                 proposal= proposal.substring(1);
340             }
341 
342             if (fIsEscape) {
343                 fPriorityProposals.add(new Proposal(proposal, displayString, additionalInfo, position));
344             } else {
345                 addProposal(proposal, position, displayString, additionalInfo);
346             }
347         }
348     }
349     
350     /**
351      * <code>true</code> iff the processor is for the find field.
352      * <code>false</code> iff the processor is for the replace field.
353      */
354     private final boolean fIsFind;
355     
356 
357     /**
358      * Creates a new completion proposal provider.
359      * 
360      * @param isFind <code>true</code> if the provider is used for the 'find' field
361      *                  <code>false</code> if the provider is used for the 'reaplce' field
362      */
363     public RegExContentProposalProvider(boolean isFind) {
364         fIsFind= isFind;
365     }
366     
367     /*
368      * @see org.eclipse.jface.fieldassist.IContentProposalProvider#getProposals(java.lang.String, int)
369      */
370     public IContentProposal [] getProposals(String   contents, int position) {
371         if (fIsFind)
372             return new ProposalComputer(contents, position).computeFindProposals();
373         return new ProposalComputer(contents, position).computeReplaceProposals();
374     }
375 }
376
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags