platform/lang-api/src/com/intellij/patterns/VirtualFilePattern.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 package com.intellij.patterns;
  18
  19 import com.intellij.openapi.fileTypes.FileType;
  20 import com.intellij.openapi.vfs.VirtualFile;
  21 import com.intellij.util.ProcessingContext;
  22 import com.intellij.util.xml.NanoXmlUtil;
  23 import org.jetbrains.annotations.NotNull;
  24
  25 import java.io.IOException;
  26
  27 /**
  28  * @author nik
  29  */
  30 public class VirtualFilePattern extends TreeElementPattern<VirtualFile, VirtualFile, VirtualFilePattern> {
  31   public VirtualFilePattern() {
  32     super(VirtualFile.class);
  33   }
  34
  35   public VirtualFilePattern ofType(final FileType type) {
  36     return with(new PatternCondition<VirtualFile>("ofType") {
  37       public boolean accepts(@NotNull final VirtualFile virtualFile, final ProcessingContext context) {
  38         return type.equals(virtualFile.getFileType());
  39       }
  40     });
  41   }
  42
  43   public VirtualFilePattern withName(final String name) {
  44     return withName(PlatformPatterns.string().equalTo(name));
  45   }
  46
  47   public VirtualFilePattern withName(final ElementPattern<String> namePattern) {
  48     return with(new PatternCondition<VirtualFile>("withName") {
  49       public boolean accepts(@NotNull final VirtualFile virtualFile, final ProcessingContext context) {
  50         return namePattern.getCondition().accepts(virtualFile.getName(), context);
  51       }
  52     });
  53   }
  54
  55   public VirtualFilePattern xmlWithRootTag(final ElementPattern<String> tagNamePattern) {
  56     return with(new PatternCondition<VirtualFile>("xmlWithRootTag") {
  57       public boolean accepts(@NotNull final VirtualFile virtualFile, final ProcessingContext context) {
  58         try {
  59           String tagName = NanoXmlUtil.parseHeaderWithException(virtualFile).getRootTagLocalName();
  60           return tagName != null && tagNamePattern.getCondition().accepts(tagName, context);
  61         }
  62         catch (IOException e) {
  63           return false;
  64         }
  65       }
  66     });
  67   }
  68   public VirtualFilePattern xmlWithRootTagNamespace(final String... namespace) {
  69     StringPattern namespacePattern = StandardPatterns.string().oneOf(namespace);
  70     return xmlWithRootTagNamespace(namespacePattern);
  71   }
  72
  73   public VirtualFilePattern xmlWithRootTagNamespace(final ElementPattern<String> namespacePattern) {
  74     return with(new PatternCondition<VirtualFile>("xmlWithRootTagNamespace") {
  75       public boolean accepts(@NotNull final VirtualFile virtualFile, final ProcessingContext context) {
  76         try {
  77           String rootTagNamespace = NanoXmlUtil.parseHeaderWithException(virtualFile).getRootTagNamespace();
  78           return rootTagNamespace != null && namespacePattern.getCondition().accepts(rootTagNamespace, context);
  79         }
  80         catch (IOException e) {
  81           return false;
  82         }
  83       }
  84     });
  85   }
  86
  87   protected VirtualFile getParent(@NotNull final VirtualFile t) {
  88     return t.getParent();
  89   }
  90
  91   protected VirtualFile[] getChildren(@NotNull final VirtualFile file) {
  92     return file.getChildren();
  93   }
  94 }