java/java-impl/src/com/intellij/psi/search/scope/packageSet/PatternPackageSetParserExtension.java

   1 /*
   2  * Copyright 2000-2009 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
  17 /*
  18  * User: anna
  19  * Date: 25-Jan-2008
  20  */
  21 package com.intellij.psi.search.scope.packageSet;
  22
  23 import com.intellij.analysis.AnalysisScopeBundle;
  24 import com.intellij.lexer.Lexer;
  25 import com.intellij.psi.search.scope.packageSet.lexer.ScopeTokenTypes;
  26
  27 public class PatternPackageSetParserExtension implements PackageSetParserExtension {
  28
  29   public PackageSet parsePackageSet(final Lexer lexer, final String scope, final String modulePattern) throws ParsingException {
  30     if (scope == PatternPackageSet.SCOPE_ANY && modulePattern == null) {
  31       error(AnalysisScopeBundle.message("error.packageset.common.expectations"), lexer);
  32     }
  33     if (scope != PatternPackageSet.SCOPE_ANY &&
  34         scope != PatternPackageSet.SCOPE_LIBRARY &&
  35         scope != PatternPackageSet.SCOPE_PROBLEM &&
  36         scope != PatternPackageSet.SCOPE_SOURCE &&
  37         scope != PatternPackageSet.SCOPE_TEST) {
  38       return null;
  39     }
  40     return new PatternPackageSet(parseAspectJPattern(lexer), scope, modulePattern);
  41   }
  42
  43   public String parseScope(final Lexer lexer) {
  44     if (lexer.getTokenType() != ScopeTokenTypes.IDENTIFIER) return PatternPackageSet.SCOPE_ANY;
  45     String id = getTokenText(lexer);
  46     String scope = PatternPackageSet.SCOPE_ANY;
  47     if (PatternPackageSet.SCOPE_SOURCE.equals(id)) {
  48       scope = PatternPackageSet.SCOPE_SOURCE;
  49     } else if (PatternPackageSet.SCOPE_TEST.equals(id)) {
  50       scope = PatternPackageSet.SCOPE_TEST;
  51     } else if (PatternPackageSet.SCOPE_PROBLEM.equals(id)) {
  52       scope = PatternPackageSet.SCOPE_PROBLEM;
  53     } else if (PatternPackageSet.SCOPE_LIBRARY.equals(id)) {
  54       scope = PatternPackageSet.SCOPE_LIBRARY;
  55     } else if (id.trim().length() > 0) {
  56       scope = null;
  57     }
  58     final CharSequence buf = lexer.getBufferSequence();
  59     int end = lexer.getTokenEnd();
  60     int bufferEnd = lexer.getBufferEnd();
  61
  62     if (scope == PatternPackageSet.SCOPE_ANY || end >= bufferEnd || buf.charAt(end) != ':' && buf.charAt(end) != '[') {
  63       return PatternPackageSet.SCOPE_ANY;
  64     }
  65
  66     if (scope != null) {
  67       lexer.advance();
  68     }
  69
  70     return scope;
  71   }
  72
  73   private static String parseAspectJPattern(Lexer lexer) throws ParsingException {
  74     StringBuffer pattern = new StringBuffer();
  75     boolean wasIdentifier = false;
  76     while (true) {
  77       if (lexer.getTokenType() == ScopeTokenTypes.DOT) {
  78         pattern.append('.');
  79         wasIdentifier = false;
  80       }
  81       else if (lexer.getTokenType() == ScopeTokenTypes.ASTERISK) {
  82         pattern.append('*');
  83         wasIdentifier = false;
  84       }
  85       else if (lexer.getTokenType() == ScopeTokenTypes.IDENTIFIER) {
  86         if (wasIdentifier) error(AnalysisScopeBundle.message("error.packageset.token.expectations", getTokenText(lexer)), lexer);
  87         wasIdentifier = true;
  88         pattern.append(getTokenText(lexer));
  89       }
  90       else {
  91         break;
  92       }
  93       lexer.advance();
  94     }
  95
  96     if (pattern.length() == 0) {
  97       error(AnalysisScopeBundle.message("error.packageset.pattern.expectations"), lexer);
  98     }
  99
 100     return pattern.toString();
 101   }
 102
 103
 104   private static String getTokenText(Lexer lexer) {
 105     int start = lexer.getTokenStart();
 106     int end = lexer.getTokenEnd();
 107     return lexer.getBufferSequence().subSequence(start, end).toString();
 108   }
 109
 110   private static void error(String message, Lexer lexer) throws ParsingException {
 111     throw new ParsingException(
 112       AnalysisScopeBundle.message("error.packageset.position.parsing.error", message, (lexer.getTokenStart() + 1)));
 113   }
 114 }