82d12a2c48ebf46e1cf0b952594f7d8eb897dc48
[idea/community.git] / xml / impl / src / com / intellij / codeInsight / template / XmlZenCodingTemplate.java
1 /*
2  * Copyright 2000-2010 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.codeInsight.template;
17
18 import com.intellij.application.options.editor.WebEditorOptions;
19 import com.intellij.codeInsight.template.impl.TemplateImpl;
20 import com.intellij.lang.xml.XMLLanguage;
21 import com.intellij.openapi.diagnostic.Logger;
22 import com.intellij.openapi.editor.Editor;
23 import com.intellij.openapi.util.Pair;
24 import com.intellij.psi.PsiElement;
25 import com.intellij.psi.PsiFile;
26 import com.intellij.psi.util.PsiTreeUtil;
27 import com.intellij.psi.xml.XmlTag;
28 import com.intellij.psi.xml.XmlToken;
29 import com.intellij.psi.xml.XmlTokenType;
30 import com.intellij.util.containers.HashMap;
31 import com.intellij.util.containers.HashSet;
32 import com.sun.org.apache.xml.internal.utils.XML11Char;
33 import org.jetbrains.annotations.NotNull;
34 import org.jetbrains.annotations.Nullable;
35
36 import java.util.*;
37
38 /**
39  * @author Eugene.Kudelevsky
40  */
41 public class XmlZenCodingTemplate implements CustomLiveTemplate {
42   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.template.XmlZenCodingTemplate");
43
44   private static final String ATTRS = "ATTRS";
45
46   private static final String OPERATIONS = ">+*";
47   private static final String SELECTORS = ".#[";
48   private static final char MARKER = '$';
49   private static final String ID = "id";
50   private static final String CLASS = "class";
51   private static final String NUMBER_IN_ITERATION_PLACE_HOLDER = "$";
52
53   private static enum MyState {
54     OPERATION, WORD, AFTER_NUMBER, NUMBER
55   }
56
57   private static class MyToken {
58   }
59
60   private static class MyMarkerToken extends MyToken {
61   }
62
63   private static class MyTemplateToken extends MyToken {
64     final String myKey;
65     final List<Pair<String, String>> myAttribute2Value;
66
67     MyTemplateToken(String key, List<Pair<String, String>> attribute2value) {
68       myKey = key;
69       myAttribute2Value = attribute2value;
70     }
71   }
72
73   private static class MyNumberToken extends MyToken {
74     final int myNumber;
75
76     MyNumberToken(int number) {
77       myNumber = number;
78     }
79   }
80
81   private static class MyOperationToken extends MyToken {
82     final char mySign;
83
84     MyOperationToken(char sign) {
85       mySign = sign;
86     }
87   }
88
89   private static int parseNonNegativeInt(@NotNull String s) {
90     try {
91       return Integer.parseInt(s);
92     }
93     catch (Throwable ignored) {
94     }
95     return -1;
96   }
97
98   private static String getPrefix(@NotNull String templateKey) {
99     for (int i = 0, n = templateKey.length(); i < n; i++) {
100       char c = templateKey.charAt(i);
101       if (SELECTORS.indexOf(c) >= 0) {
102         return templateKey.substring(0, i);
103       }
104     }
105     return templateKey;
106   }
107
108   @Nullable
109   private static Pair<String, String> parseAttrNameAndValue(@NotNull String text) {
110     int eqIndex = text.indexOf('=');
111     if (eqIndex > 0) {
112       return new Pair<String, String>(text.substring(0, eqIndex), text.substring(eqIndex + 1));
113     }
114     return null;
115   }
116
117   @Nullable
118   private static MyTemplateToken parseSelectors(@NotNull String text) {
119     String templateKey = null;
120     List<Pair<String, String>> attributes = new ArrayList<Pair<String, String>>();
121     Set<String> definedAttrs = new HashSet<String>();
122     final List<String> classes = new ArrayList<String>();
123     StringBuilder builder = new StringBuilder();
124     char lastDelim = 0;
125     text += MARKER;
126     int classAttrPosition = -1;
127     for (int i = 0, n = text.length(); i < n; i++) {
128       char c = text.charAt(i);
129       if (c == '#' || c == '.' || c == '[' || c == ']' || i == n - 1) {
130         if (c != ']') {
131           switch (lastDelim) {
132             case 0:
133               templateKey = builder.toString();
134               break;
135             case '#':
136               if (!definedAttrs.add(ID)) {
137                 return null;
138               }
139               attributes.add(new Pair<String, String>(ID, builder.toString()));
140               break;
141             case '.':
142               if (builder.length() <= 0) {
143                 return null;
144               }
145               if (classAttrPosition < 0) {
146                 classAttrPosition = attributes.size();
147               }
148               classes.add(builder.toString());
149               break;
150             case ']':
151               if (builder.length() > 0) {
152                 return null;
153               }
154               break;
155             default:
156               return null;
157           }
158         }
159         else if (lastDelim != '[') {
160           return null;
161         }
162         else {
163           Pair<String, String> pair = parseAttrNameAndValue(builder.toString());
164           if (pair == null || !definedAttrs.add(pair.first)) {
165             return null;
166           }
167           attributes.add(pair);
168         }
169         lastDelim = c;
170         builder = new StringBuilder();
171       }
172       else {
173         builder.append(c);
174       }
175     }
176     if (classes.size() > 0) {
177       if (definedAttrs.contains(CLASS)) {
178         return null;
179       }
180       StringBuilder classesAttrValue = new StringBuilder();
181       for (int i = 0; i < classes.size(); i++) {
182         classesAttrValue.append(classes.get(i));
183         if (i < classes.size() - 1) {
184           classesAttrValue.append(' ');
185         }
186       }
187       assert classAttrPosition >= 0;
188       attributes.add(classAttrPosition, new Pair<String, String>(CLASS, classesAttrValue.toString()));
189     }
190     return new MyTemplateToken(templateKey, attributes);
191   }
192
193   @Nullable
194   private static List<MyToken> parse(@NotNull String text, @NotNull CustomTemplateCallback callback) {
195     text += MARKER;
196     StringBuilder templateKeyBuilder = new StringBuilder();
197     List<MyToken> result = new ArrayList<MyToken>();
198     for (int i = 0, n = text.length(); i < n; i++) {
199       char c = text.charAt(i);
200       if (i == n - 1 || (i < n - 2 && OPERATIONS.indexOf(c) >= 0)) {
201         String key = templateKeyBuilder.toString();
202         templateKeyBuilder = new StringBuilder();
203         int num = parseNonNegativeInt(key);
204         if (num > 0) {
205           result.add(new MyNumberToken(num));
206         }
207         else {
208           if (key.length() == 0) {
209             return null;
210           }
211           String prefix = getPrefix(key);
212           if (!callback.isLiveTemplateApplicable(prefix) && !XML11Char.isXML11ValidQName(prefix)) {
213             return null;
214           }
215           MyTemplateToken token = parseSelectors(key);
216           if (token == null) {
217             return null;
218           }
219           result.add(token);
220         }
221         result.add(i < n - 1 ? new MyOperationToken(c) : new MyMarkerToken());
222       }
223       else if (!Character.isWhitespace(c)) {
224         templateKeyBuilder.append(c);
225       }
226       else {
227         return null;
228       }
229     }
230     return result;
231   }
232
233   private static boolean check(@NotNull Collection<MyToken> tokens) {
234     MyState state = MyState.WORD;
235     for (MyToken token : tokens) {
236       if (token instanceof MyMarkerToken) {
237         break;
238       }
239       switch (state) {
240         case OPERATION:
241           if (token instanceof MyOperationToken) {
242             state = ((MyOperationToken)token).mySign == '*' ? MyState.NUMBER : MyState.WORD;
243           }
244           else {
245             return false;
246           }
247           break;
248         case WORD:
249           if (token instanceof MyTemplateToken) {
250             state = MyState.OPERATION;
251           }
252           else {
253             return false;
254           }
255           break;
256         case NUMBER:
257           if (token instanceof MyNumberToken) {
258             state = MyState.AFTER_NUMBER;
259           }
260           else {
261             return false;
262           }
263           break;
264         case AFTER_NUMBER:
265           if (token instanceof MyOperationToken && ((MyOperationToken)token).mySign != '*') {
266             state = MyState.WORD;
267           }
268           else {
269             return false;
270           }
271           break;
272       }
273     }
274     return state == MyState.OPERATION || state == MyState.AFTER_NUMBER;
275   }
276
277   private static String computeKey(Editor editor, int startOffset) {
278     int offset = editor.getCaretModel().getOffset();
279     String s = editor.getDocument().getCharsSequence().subSequence(startOffset, offset).toString();
280     int index = 0;
281     while (index < s.length() && Character.isWhitespace(s.charAt(index))) {
282       index++;
283     }
284     String key = s.substring(index);
285     int lastWhitespaceIndex = -1;
286     for (int i = 0; i < key.length(); i++) {
287       if (Character.isWhitespace(key.charAt(i))) {
288         lastWhitespaceIndex = i;
289       }
290     }
291     if (lastWhitespaceIndex >= 0 && lastWhitespaceIndex < key.length() - 1) {
292       return key.substring(lastWhitespaceIndex + 1);
293     }
294     return key;
295   }
296
297   public String computeTemplateKey(@NotNull CustomTemplateCallback callback) {
298     Editor editor = callback.getEditor();
299     int offset = callback.getOffset();
300     PsiElement element = callback.getFile().findElementAt(offset > 0 ? offset - 1 : offset);
301     int line = editor.getCaretModel().getLogicalPosition().line;
302     int lineStart = editor.getDocument().getLineStartOffset(line);
303     int parentStart;
304     do {
305       parentStart = element != null ? element.getTextRange().getStartOffset() : 0;
306       int startOffset = parentStart > lineStart ? parentStart : lineStart;
307       String key = computeKey(editor, startOffset);
308       List<MyToken> tokens = parse(key, callback);
309       if (tokens != null && check(tokens)) {
310         if (tokens.size() == 2) {
311           MyToken token = tokens.get(0);
312           if (token instanceof MyTemplateToken) {
313             if (key.equals(((MyTemplateToken)token).myKey) && callback.isLiveTemplateApplicable(key)) {
314               // do not activate only live template
315               return null;
316             }
317           }
318         }
319         return key;
320       }
321       if (element != null) {
322         element = element.getParent();
323       }
324     }
325     while (element != null && parentStart > lineStart);
326     return null;
327   }
328
329   public boolean isApplicable(PsiFile file, int offset, boolean selection) {
330     WebEditorOptions webEditorOptions = WebEditorOptions.getInstance();
331     if (!webEditorOptions.isZenCodingEnabled()) {
332       return false;
333     }
334     if (file.getLanguage() instanceof XMLLanguage) {
335       PsiElement element = file.findElementAt(offset > 0 ? offset - 1 : offset);
336       if (element == null || element.getLanguage() instanceof XMLLanguage) {
337         return true;
338       }
339     }
340     return false;
341   }
342
343   public void expand(String key, @NotNull CustomTemplateCallback callback, @Nullable TemplateInvokationListener listener) {
344     List<MyToken> tokens = parse(key, callback);
345     assert tokens != null;
346     MyInterpreter interpreter = new MyInterpreter(tokens, callback, MyState.WORD, listener);
347     interpreter.invoke(0);
348   }
349
350   public void wrap(String selection, @NotNull CustomTemplateCallback callback, @Nullable TemplateInvokationListener listener) {
351   }
352
353   private static void fail() {
354     LOG.error("Input string was checked incorrectly during isApplicable() invokation");
355   }
356
357   @NotNull
358   private static String buildAttributesString(List<Pair<String, String>> attribute2value, int numberInIteration) {
359     StringBuilder result = new StringBuilder();
360     for (Iterator<Pair<String, String>> it = attribute2value.iterator(); it.hasNext();) {
361       Pair<String, String> pair = it.next();
362       String name = pair.first;
363       String value = pair.second.replace(NUMBER_IN_ITERATION_PLACE_HOLDER, Integer.toString(numberInIteration + 1));
364       result.append(name).append("=\"").append(value).append('"');
365       if (it.hasNext()) {
366         result.append(' ');
367       }
368     }
369     return result.toString();
370   }
371
372   private static boolean invokeTemplate(MyTemplateToken token,
373                                         final CustomTemplateCallback callback,
374                                         final TemplateInvokationListener listener,
375                                         int numberInIteration) {
376     String attributes = buildAttributesString(token.myAttribute2Value, numberInIteration);
377     attributes = attributes.length() > 0 ? ' ' + attributes : null;
378     Map<String, String> predefinedValues = null;
379     if (attributes != null) {
380       predefinedValues = new HashMap<String, String>();
381       predefinedValues.put(ATTRS, attributes);
382     }
383     if (callback.isLiveTemplateApplicable(token.myKey)) {
384       if (attributes != null && !callback.templateContainsVars(token.myKey, ATTRS)) {
385         TemplateImpl newTemplate = generateTemplateWithAttributes(token.myKey, attributes, callback);
386         if (newTemplate != null) {
387           return callback.startTemplate(newTemplate, predefinedValues, listener);
388         }
389       }
390       return callback.startTemplate(token.myKey, predefinedValues, listener);
391     }
392     else {
393       TemplateImpl template = new TemplateImpl("", "");
394       template.addTextSegment('<' + token.myKey);
395       if (attributes != null) {
396         template.addVariable(ATTRS, "", "", false);
397         template.addVariableSegment(ATTRS);
398       }
399       template.addTextSegment(">");
400       template.addVariableSegment(TemplateImpl.END);
401       template.addTextSegment("</" + token.myKey + ">");
402       template.setToReformat(true);
403       return callback.startTemplate(template, predefinedValues, listener);
404     }
405   }
406
407   private static int findPlaceToInsertAttrs(@NotNull TemplateImpl template) {
408     String s = template.getString();
409     if (s.length() > 0) {
410       if (s.charAt(0) != '<') {
411         return -1;
412       }
413       int i = 1;
414       while (i < s.length() && !Character.isWhitespace(s.charAt(i)) && s.charAt(i) != '>') {
415         i++;
416       }
417       if (i == 1) {
418         return -1;
419       }
420       if (s.indexOf('>', i) >= i) {
421         return i;
422       }
423     }
424     return -1;
425   }
426
427   @Nullable
428   private static TemplateImpl generateTemplateWithAttributes(String key, String attributes, CustomTemplateCallback callback) {
429     TemplateImpl template = callback.findApplicableTemplate(key);
430     assert template != null;
431     String templateString = template.getString();
432     int offset = findPlaceToInsertAttrs(template);
433     if (offset >= 0) {
434       String newTemplateString = templateString.substring(0, offset) + attributes + templateString.substring(offset);
435       TemplateImpl newTemplate = template.copy();
436       newTemplate.setString(newTemplateString);
437       return newTemplate;
438     }
439     return null;
440   }
441
442   /*private static boolean hasClosingTag(CharSequence text, CharSequence tagName, int offset, int rightBound) {
443     if (offset + 1 < text.length() && text.charAt(offset) == '<' && text.charAt(offset + 1) == '/') {
444       CharSequence closingTagName = parseTagName(text, offset + 2, rightBound);
445       if (tagName.equals(closingTagName)) {
446         return true;
447       }
448     }
449     return false;
450   }*/
451
452   private class MyInterpreter {
453     private final List<MyToken> myTokens;
454     private final CustomTemplateCallback myCallback;
455     private final TemplateInvokationListener myListener;
456     private MyState myState;
457
458     private MyInterpreter(List<MyToken> tokens,
459                           CustomTemplateCallback callback,
460                           MyState initialState,
461                           TemplateInvokationListener listener) {
462       myTokens = tokens;
463       myCallback = callback;
464       myListener = listener;
465       myState = initialState;
466     }
467
468     private void finish(boolean inSeparateEvent) {
469       myCallback.gotoEndOffset();
470       if (myListener != null) {
471         myListener.finished(inSeparateEvent);
472       }
473     }
474
475     private void gotoChild(Object templateBoundsKey) {
476       int startOfTemplate = myCallback.getStartOfTemplate(templateBoundsKey);
477       int endOfTemplate = myCallback.getEndOfTemplate(templateBoundsKey);
478       Editor editor = myCallback.getEditor();
479       int offset = myCallback.getOffset();
480
481       PsiFile file = myCallback.getFile();
482
483       PsiElement element = file.findElementAt(offset);
484       if (element instanceof XmlToken && ((XmlToken)element).getTokenType() == XmlTokenType.XML_END_TAG_START) {
485         return;
486       }
487
488       int newOffset = -1;
489       XmlTag tag = PsiTreeUtil.findElementOfClassAtRange(file, startOfTemplate, endOfTemplate, XmlTag.class);
490       if (tag != null) {
491         for (PsiElement child : tag.getChildren()) {
492           if (child instanceof XmlToken && ((XmlToken)child).getTokenType() == XmlTokenType.XML_END_TAG_START) {
493             newOffset = child.getTextOffset();
494           }
495         }
496       }
497
498       if (newOffset >= 0) {
499         myCallback.fixEndOffset();
500         editor.getCaretModel().moveToOffset(newOffset);
501       }
502
503       /*CharSequence tagName = getPrecedingTagName(text, offset, startOfTemplate);
504       if (tagName != null) {
505         *//*if (!hasClosingTag(text, tagName, offset, endOfTemplate)) {
506           document.insertString(offset, "</" + tagName + '>');
507         }*//*
508       }
509       else if (offset != endOfTemplate) {
510         tagName = getPrecedingTagName(text, endOfTemplate, startOfTemplate);
511         if (tagName != null) {
512           *//*fixEndOffset();
513           document.insertString(endOfTemplate, "</" + tagName + '>');*//*
514           editor.getCaretModel().moveToOffset(endOfTemplate);
515         }
516       }*/
517     }
518
519     public boolean invoke(int startIndex) {
520       final int n = myTokens.size();
521       MyTemplateToken templateToken = null;
522       int number = -1;
523       for (int i = startIndex; i < n; i++) {
524         final int finalI = i;
525         MyToken token = myTokens.get(i);
526         switch (myState) {
527           case OPERATION:
528             if (templateToken != null) {
529               if (token instanceof MyMarkerToken || token instanceof MyOperationToken) {
530                 final char sign = token instanceof MyOperationToken ? ((MyOperationToken)token).mySign : MARKER;
531                 if (sign == MARKER || sign == '+') {
532                   final Object key = new Object();
533                   myCallback.fixStartOfTemplate(key);
534                   TemplateInvokationListener listener = new TemplateInvokationListener() {
535                     public void finished(boolean inSeparateEvent) {
536                       myState = MyState.WORD;
537                       if (myCallback.getOffset() != myCallback.getEndOfTemplate(key)) {
538                         myCallback.fixEndOffset();
539                       }
540                       if (sign == '+') {
541                         myCallback.gotoEndOfTemplate(key);
542                       }
543                       if (inSeparateEvent) {
544                         invoke(finalI + 1);
545                       }
546                     }
547                   };
548                   if (!invokeTemplate(templateToken, myCallback, listener, -1)) {
549                     return false;
550                   }
551                   templateToken = null;
552                 }
553                 else if (sign == '>') {
554                   if (!startTemplateAndGotoChild(templateToken, finalI)) {
555                     return false;
556                   }
557                   templateToken = null;
558                 }
559                 else if (sign == '*') {
560                   myState = MyState.NUMBER;
561                 }
562               }
563               else {
564                 fail();
565               }
566             }
567             break;
568           case WORD:
569             if (token instanceof MyTemplateToken) {
570               templateToken = ((MyTemplateToken)token);
571               myState = MyState.OPERATION;
572             }
573             else {
574               fail();
575             }
576             break;
577           case NUMBER:
578             if (token instanceof MyNumberToken) {
579               number = ((MyNumberToken)token).myNumber;
580               myState = MyState.AFTER_NUMBER;
581             }
582             else {
583               fail();
584             }
585             break;
586           case AFTER_NUMBER:
587             if (token instanceof MyMarkerToken || token instanceof MyOperationToken) {
588               char sign = token instanceof MyOperationToken ? ((MyOperationToken)token).mySign : MARKER;
589               if (sign == MARKER || sign == '+') {
590                 if (!invokeTemplateSeveralTimes(templateToken, 0, number, finalI)) {
591                   return false;
592                 }
593                 templateToken = null;
594               }
595               else if (number > 1) {
596                 return invokeTemplateAndProcessTail(templateToken, 0, number, i + 1);
597               }
598               else {
599                 assert number == 1;
600                 if (!startTemplateAndGotoChild(templateToken, finalI)) {
601                   return false;
602                 }
603                 templateToken = null;
604               }
605               myState = MyState.WORD;
606             }
607             else {
608               fail();
609             }
610             break;
611         }
612       }
613       finish(startIndex == n);
614       return true;
615     }
616
617     private boolean startTemplateAndGotoChild(MyTemplateToken templateToken, final int index) {
618       final Object key = new Object();
619       myCallback.fixStartOfTemplate(key);
620       TemplateInvokationListener listener = new TemplateInvokationListener() {
621         public void finished(boolean inSeparateEvent) {
622           myState = MyState.WORD;
623           gotoChild(key);
624           if (inSeparateEvent) {
625             invoke(index + 1);
626           }
627         }
628       };
629       if (!invokeTemplate(templateToken, myCallback, listener, -1)) {
630         return false;
631       }
632       return true;
633     }
634
635     private boolean invokeTemplateSeveralTimes(final MyTemplateToken templateToken,
636                                                final int startIndex,
637                                                final int count,
638                                                final int globalIndex) {
639       final Object key = new Object();
640       myCallback.fixStartOfTemplate(key);
641       for (int i = startIndex; i < count; i++) {
642         final int finalI = i;
643         TemplateInvokationListener listener = new TemplateInvokationListener() {
644           public void finished(boolean inSeparateEvent) {
645             myState = MyState.WORD;
646             if (myCallback.getOffset() != myCallback.getEndOfTemplate(key)) {
647               myCallback.fixEndOffset();
648             }
649             myCallback.gotoEndOfTemplate(key);
650             if (inSeparateEvent) {
651               if (finalI + 1 < count) {
652                 invokeTemplateSeveralTimes(templateToken, finalI + 1, count, globalIndex);
653               }
654               else {
655                 invoke(globalIndex + 1);
656               }
657             }
658           }
659         };
660         if (!invokeTemplate(templateToken, myCallback, listener, i)) {
661           return false;
662         }
663       }
664       return true;
665     }
666
667     private boolean invokeTemplateAndProcessTail(final MyTemplateToken templateToken,
668                                                  final int startIndex,
669                                                  final int count,
670                                                  final int tailStart) {
671       final Object key = new Object();
672       myCallback.fixStartOfTemplate(key);
673       for (int i = startIndex; i < count; i++) {
674         final int finalI = i;
675         final boolean[] flag = new boolean[]{false};
676         TemplateInvokationListener listener = new TemplateInvokationListener() {
677           public void finished(boolean inSeparateEvent) {
678             gotoChild(key);
679             MyInterpreter interpreter = new MyInterpreter(myTokens, myCallback, MyState.WORD, new TemplateInvokationListener() {
680               public void finished(boolean inSeparateEvent) {
681                 if (myCallback.getOffset() != myCallback.getEndOfTemplate(key)) {
682                   myCallback.fixEndOffset();
683                 }
684                 myCallback.gotoEndOfTemplate(key);
685                 if (inSeparateEvent) {
686                   invokeTemplateAndProcessTail(templateToken, finalI + 1, count, tailStart);
687                 }
688               }
689             });
690             if (interpreter.invoke(tailStart)) {
691               if (inSeparateEvent) {
692                 invokeTemplateAndProcessTail(templateToken, finalI + 1, count, tailStart);
693               }
694             }
695             else {
696               flag[0] = true;
697             }
698           }
699         };
700         if (!invokeTemplate(templateToken, myCallback, listener, i) || flag[0]) {
701           return false;
702         }
703       }
704       finish(count == 0);
705       return true;
706     }
707   }
708 }