xml/relaxng/src/org/intellij/plugins/relaxNG/model/descriptors/RngNsDescriptor.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2007 Sascha Weinreuter
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.intellij.plugins.relaxNG.model.descriptors;

 import com.intellij.codeInsight.daemon.Validator;
 import com.intellij.javaee.ExternalResourceManager;
 import com.intellij.openapi.project.DumbService;
 import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.ModificationTracker;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileManager;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
 import com.intellij.psi.search.PsiElementProcessor;
 import com.intellij.psi.util.*;
 import com.intellij.psi.xml.XmlDocument;
 import com.intellij.psi.xml.XmlFile;
 import com.intellij.psi.xml.XmlTag;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.HashMap;
 import com.intellij.xml.XmlElementDescriptor;
 import com.intellij.xml.XmlNSDescriptorEx;
 import com.intellij.xml.impl.schema.AnyXmlElementDescriptor;
 import org.intellij.plugins.relaxNG.ApplicationLoader;
 import org.intellij.plugins.relaxNG.model.resolve.RelaxIncludeIndex;
 import org.intellij.plugins.relaxNG.validation.RngParser;
 import org.intellij.plugins.relaxNG.validation.XmlInstanceValidator;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.kohsuke.rngom.digested.DElementPattern;
 import org.kohsuke.rngom.digested.DPattern;
 import org.kohsuke.rngom.nc.NameClass;

 import javax.xml.namespace.QName;
 import java.util.*;

 /**
  * Created by IntelliJ IDEA.
  * User: sweinreuter
  * Date: 18.07.2007
  */
 public class RngNsDescriptor implements XmlNSDescriptorEx, Validator {
   private final Map<QName, CachedValue<XmlElementDescriptor>> myDescriptorsMap =
     Collections.synchronizedMap(new HashMap<QName, CachedValue<XmlElementDescriptor>>());

   private static final Key<ParameterizedCachedValue<XmlElementDescriptor, RngNsDescriptor>> ROOT_KEY = Key.create("ROOT_DESCRIPTOR");

   private XmlFile myFile;
   private PsiElement myElement;
   private String myUrl;

   private DPattern myPattern;
   private PsiManager myManager;

   @Override
   @Nullable
   public XmlElementDescriptor getElementDescriptor(@NotNull XmlTag tag) {
     if (myPattern == null) {
       return null;
     }

     XmlTag _tag = tag;
     final LinkedList<XmlTag> chain = new LinkedList<XmlTag>();
     while (_tag != null) {
       chain.addFirst(_tag);
       _tag = _tag.getParentTag();
     }

     XmlElementDescriptor desc;
     do {
       desc = findRootDescriptor(chain.removeFirst());
     } while (desc == null && chain.size() > 0);

     if (desc != null) {
       for (XmlTag xmlTag : chain) {
         desc = desc.getElementDescriptor(xmlTag, xmlTag.getParentTag());
         if (desc == null) {
           break;
         }
       }
     }

     if (desc == null || desc instanceof AnyXmlElementDescriptor) {
       return findRootDescriptor(tag);
     }

     return desc;
   }

   private XmlElementDescriptor findRootDescriptor(final XmlTag tag) {
     return CachedValuesManager.getManager(tag.getProject())
         .getParameterizedCachedValue(tag, ROOT_KEY, new ParameterizedCachedValueProvider<XmlElementDescriptor, RngNsDescriptor>() {
           @Override
           public CachedValueProvider.Result<XmlElementDescriptor> compute(RngNsDescriptor o) {
             final XmlElementDescriptor descr = o.findRootDescriptorInner(tag);
             if (descr != null) {
               return CachedValueProvider.Result.create(descr, tag, descr.getDependences(), o.getDependences());
             }
             else {
               return CachedValueProvider.Result.create(null, tag, o.getDependences());
             }
           }
         }, false, this);
   }

   private XmlElementDescriptor findRootDescriptorInner(XmlTag tag) {
     final List<DElementPattern> allNamedPatterns =
       ContainerUtil.findAll(ChildElementFinder.find(-1, myPattern), NamedPatternFilter.INSTANCE);
     XmlElementDescriptor descriptor = findDescriptor(tag, allNamedPatterns);
     return descriptor != null ? descriptor : findDescriptor(tag, ChildElementFinder.find(myPattern));
   }

   private XmlElementDescriptor findRootDescriptorInner(QName qName) {
     return findDescriptor(qName, ContainerUtil.findAll(
       ChildElementFinder.find(-1, myPattern), NamedPatternFilter.INSTANCE));
   }

   public XmlElementDescriptor findDescriptor(XmlTag tag, List<DElementPattern> list) {
     final QName qName = new QName(tag.getNamespace(), tag.getLocalName());

     return findDescriptor(qName, list);
   }

   private XmlElementDescriptor findDescriptor(final QName qName, List<DElementPattern> list) {
     int max = -1;
     DElementPattern maxPattern = null;
     for (DElementPattern pattern : list) {
       final NameClass nameClass = pattern.getName();
       if (nameClass.contains(qName)) {
         final int spec = nameClass.containsSpecificity(qName);
         if (spec > max) {
           maxPattern = pattern;
           max = spec;
         }
       }
     }
     final List<DElementPattern> patterns = ContainerUtil.findAll(list, new Condition<DElementPattern>() {
       @Override
       public boolean value(DElementPattern pattern) {
         final NameClass nameClass = pattern.getName();
         return nameClass.contains(qName);
       }
     });

     if (maxPattern != null) {
       if (patterns.size() > 1) {
         return initDescriptor(new CompositeDescriptor(this, maxPattern, patterns));
       } else {
         return initDescriptor(new RngElementDescriptor(this, maxPattern));
       }
     } else {
       return null;
     }
   }

   @Override
   @NotNull
   public XmlElementDescriptor[] getRootElementsDescriptors(@Nullable XmlDocument document) {
     if (myPattern == null) {
       return XmlElementDescriptor.EMPTY_ARRAY;
     }

     final List<DElementPattern> list = ChildElementFinder.find(-1, myPattern);
     return convertElementDescriptors(list);
   }

   XmlElementDescriptor[] convertElementDescriptors(List<DElementPattern> patterns) {
     patterns = ContainerUtil.findAll(patterns, NamedPatternFilter.INSTANCE);

     final Map<QName, List<DElementPattern>> name2patterns = new HashMap<QName, List<DElementPattern>>();
     for (DElementPattern pattern : patterns) {
       for (QName qName : pattern.getName().listNames()) {
         List<DElementPattern> dPatterns = name2patterns.get(qName);
         if (dPatterns == null) {
           dPatterns = new ArrayList<DElementPattern>();
           name2patterns.put(qName, dPatterns);
         }
         if (!dPatterns.contains(pattern)) dPatterns.add(pattern);
       }
     }

     final List<XmlElementDescriptor> result = new ArrayList<XmlElementDescriptor>();

     for (QName qName : name2patterns.keySet()) {
       final List<DElementPattern> patternList = name2patterns.get(qName);
       final XmlElementDescriptor descriptor = findDescriptor(qName, patternList);
       if (descriptor != null) {
         result.add(descriptor);
       }
     }

     return result.toArray(new XmlElementDescriptor[result.size()]);
   }

   protected XmlElementDescriptor initDescriptor(@NotNull XmlElementDescriptor descriptor) {
     return descriptor;
   }

   @Override
   @NotNull
   public XmlFile getDescriptorFile() {
     return myFile;
   }

   @Override
   public boolean isHierarhyEnabled() {
     return false;
   }

   @Override
   public synchronized PsiElement getDeclaration() {
     if (!myElement.isValid() || !myFile.isValid()) {
       if (myUrl != null) {
         final VirtualFile fileByUrl = VirtualFileManager.getInstance().findFileByUrl(myUrl);
         if (fileByUrl != null) {
           final PsiFile file = myManager.findFile(fileByUrl);
           if (file instanceof XmlFile) {
             init(((XmlFile)file).getDocument());
           }
         }
       }
     }
     return myFile.isValid() ? myFile.getDocument() : null;
   }

   @Override
   @NonNls
   public String getName(PsiElement context) {
     return getName();
   }

   @Override
   @NonNls
   public String getName() {
     return getDescriptorFile().getName();
   }

   @Override
   public Object[] getDependences() {
     if (myPattern != null) {
       if (DumbService.isDumb(myElement.getProject())) {
         return new Object[] { ModificationTracker.EVER_CHANGED, ExternalResourceManager.getInstance()};
       }
       final Object[] a = { myElement, ExternalResourceManager.getInstance() };
       final PsiElementProcessor.CollectElements<XmlFile> processor = new PsiElementProcessor.CollectElements<XmlFile>();
       RelaxIncludeIndex.processForwardDependencies(myFile, processor);
       if (processor.getCollection().size() > 0) {
         return ArrayUtil.mergeArrays(a, processor.toArray());
       } else {
         return a;
       }
     }
     return new Object[]{ ModificationTracker.EVER_CHANGED };
   }

   @Override
   public synchronized void init(PsiElement element) {
     myElement = element;
     myFile = element instanceof XmlFile ? (XmlFile)element : (XmlFile)element.getContainingFile();
     myManager = myFile.getManager();

     final VirtualFile file = myFile.getVirtualFile();
     if (file != null) {
       myUrl = file.getUrl();
     }

     myPattern = RngParser.getCachedPattern(getDescriptorFile(), RngParser.DEFAULT_HANDLER);
   }

   @Override
   public void validate(@NotNull PsiElement context, @NotNull final ValidationHost host) {
     final XmlDocument doc = PsiTreeUtil.getContextOfType(context, XmlDocument.class, false);
     if (doc == null) {
       return;
     }
     final XmlTag rootTag = doc.getRootTag();
     if (rootTag == null) {
       return;
     }
     // RNG XML itself is validated by parsing it with Jing, so we don't want to schema-validate it
     if (!ApplicationLoader.RNG_NAMESPACE.equals(rootTag.getNamespace())) {
       XmlInstanceValidator.doValidation(doc, host, getDescriptorFile());
     }
   }

   //@Override
   @Override
   public XmlElementDescriptor getElementDescriptor(String localName, String namespace) {
     final QName qName = new QName(namespace, localName);
     CachedValue<XmlElementDescriptor> cachedValue = myDescriptorsMap.get(qName);
     if (cachedValue == null) {
       cachedValue =
         CachedValuesManager.getManager(myElement.getProject()).createCachedValue(new CachedValueProvider<XmlElementDescriptor>() {
           @Override
           public Result<XmlElementDescriptor> compute() {
             final XmlElementDescriptor descriptor = findRootDescriptorInner(qName);
             return descriptor != null
                    ? new Result<XmlElementDescriptor>(descriptor, descriptor.getDependences())
                    : new Result<XmlElementDescriptor>(null, getDependences());
           }
         }, false);
       myDescriptorsMap.put(qName, cachedValue);
     }
     return cachedValue.getValue();
   }
 }
	/*
	* Copyright 2007 Sascha Weinreuter
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.intellij.plugins.relaxNG.model.descriptors;

	import com.intellij.codeInsight.daemon.Validator;
	import com.intellij.javaee.ExternalResourceManager;
	import com.intellij.openapi.project.DumbService;
	import com.intellij.openapi.util.Condition;
	import com.intellij.openapi.util.Key;
	import com.intellij.openapi.util.ModificationTracker;
	import com.intellij.openapi.vfs.VirtualFile;
	import com.intellij.openapi.vfs.VirtualFileManager;
	import com.intellij.psi.PsiElement;
	import com.intellij.psi.PsiFile;
	import com.intellij.psi.PsiManager;
	import com.intellij.psi.search.PsiElementProcessor;
	import com.intellij.psi.util.*;
	import com.intellij.psi.xml.XmlDocument;
	import com.intellij.psi.xml.XmlFile;
	import com.intellij.psi.xml.XmlTag;
	import com.intellij.util.ArrayUtil;
	import com.intellij.util.containers.ContainerUtil;
	import com.intellij.util.containers.HashMap;
	import com.intellij.xml.XmlElementDescriptor;
	import com.intellij.xml.XmlNSDescriptorEx;
	import com.intellij.xml.impl.schema.AnyXmlElementDescriptor;
	import org.intellij.plugins.relaxNG.ApplicationLoader;
	import org.intellij.plugins.relaxNG.model.resolve.RelaxIncludeIndex;
	import org.intellij.plugins.relaxNG.validation.RngParser;
	import org.intellij.plugins.relaxNG.validation.XmlInstanceValidator;
	import org.jetbrains.annotations.NonNls;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;
	import org.kohsuke.rngom.digested.DElementPattern;
	import org.kohsuke.rngom.digested.DPattern;
	import org.kohsuke.rngom.nc.NameClass;

	import javax.xml.namespace.QName;
	import java.util.*;

	/**
	* Created by IntelliJ IDEA.
	* User: sweinreuter
	* Date: 18.07.2007
	*/
	public class RngNsDescriptor implements XmlNSDescriptorEx, Validator {
	private final Map<QName, CachedValue<XmlElementDescriptor>> myDescriptorsMap =
	Collections.synchronizedMap(new HashMap<QName, CachedValue<XmlElementDescriptor>>());

	private static final Key<ParameterizedCachedValue<XmlElementDescriptor, RngNsDescriptor>> ROOT_KEY = Key.create("ROOT_DESCRIPTOR");

	private XmlFile myFile;
	private PsiElement myElement;
	private String myUrl;

	private DPattern myPattern;
	private PsiManager myManager;

	@Override
	@Nullable
	public XmlElementDescriptor getElementDescriptor(@NotNull XmlTag tag) {
	if (myPattern == null) {
	return null;
	}

	XmlTag _tag = tag;
	final LinkedList<XmlTag> chain = new LinkedList<XmlTag>();
	while (_tag != null) {
	chain.addFirst(_tag);
	_tag = _tag.getParentTag();
	}

	XmlElementDescriptor desc;
	do {
	desc = findRootDescriptor(chain.removeFirst());
	} while (desc == null && chain.size() > 0);

	if (desc != null) {
	for (XmlTag xmlTag : chain) {
	desc = desc.getElementDescriptor(xmlTag, xmlTag.getParentTag());
	if (desc == null) {
	break;
	}
	}
	}

	if (desc == null \|\| desc instanceof AnyXmlElementDescriptor) {
	return findRootDescriptor(tag);
	}

	return desc;
	}

	private XmlElementDescriptor findRootDescriptor(final XmlTag tag) {
	return CachedValuesManager.getManager(tag.getProject())
	.getParameterizedCachedValue(tag, ROOT_KEY, new ParameterizedCachedValueProvider<XmlElementDescriptor, RngNsDescriptor>() {
	@Override
	public CachedValueProvider.Result<XmlElementDescriptor> compute(RngNsDescriptor o) {
	final XmlElementDescriptor descr = o.findRootDescriptorInner(tag);
	if (descr != null) {
	return CachedValueProvider.Result.create(descr, tag, descr.getDependences(), o.getDependences());
	}
	else {
	return CachedValueProvider.Result.create(null, tag, o.getDependences());
	}
	}
	}, false, this);
	}

	private XmlElementDescriptor findRootDescriptorInner(XmlTag tag) {
	final List<DElementPattern> allNamedPatterns =
	ContainerUtil.findAll(ChildElementFinder.find(-1, myPattern), NamedPatternFilter.INSTANCE);
	XmlElementDescriptor descriptor = findDescriptor(tag, allNamedPatterns);
	return descriptor != null ? descriptor : findDescriptor(tag, ChildElementFinder.find(myPattern));
	}

	private XmlElementDescriptor findRootDescriptorInner(QName qName) {
	return findDescriptor(qName, ContainerUtil.findAll(
	ChildElementFinder.find(-1, myPattern), NamedPatternFilter.INSTANCE));
	}

	public XmlElementDescriptor findDescriptor(XmlTag tag, List<DElementPattern> list) {
	final QName qName = new QName(tag.getNamespace(), tag.getLocalName());

	return findDescriptor(qName, list);
	}

	private XmlElementDescriptor findDescriptor(final QName qName, List<DElementPattern> list) {
	int max = -1;
	DElementPattern maxPattern = null;
	for (DElementPattern pattern : list) {
	final NameClass nameClass = pattern.getName();
	if (nameClass.contains(qName)) {
	final int spec = nameClass.containsSpecificity(qName);
	if (spec > max) {
	maxPattern = pattern;
	max = spec;
	}
	}
	}
	final List<DElementPattern> patterns = ContainerUtil.findAll(list, new Condition<DElementPattern>() {
	@Override
	public boolean value(DElementPattern pattern) {
	final NameClass nameClass = pattern.getName();
	return nameClass.contains(qName);
	}
	});

	if (maxPattern != null) {
	if (patterns.size() > 1) {
	return initDescriptor(new CompositeDescriptor(this, maxPattern, patterns));
	} else {
	return initDescriptor(new RngElementDescriptor(this, maxPattern));
	}
	} else {
	return null;
	}
	}

	@Override
	@NotNull
	public XmlElementDescriptor[] getRootElementsDescriptors(@Nullable XmlDocument document) {
	if (myPattern == null) {
	return XmlElementDescriptor.EMPTY_ARRAY;
	}

	final List<DElementPattern> list = ChildElementFinder.find(-1, myPattern);
	return convertElementDescriptors(list);
	}

	XmlElementDescriptor[] convertElementDescriptors(List<DElementPattern> patterns) {
	patterns = ContainerUtil.findAll(patterns, NamedPatternFilter.INSTANCE);

	final Map<QName, List<DElementPattern>> name2patterns = new HashMap<QName, List<DElementPattern>>();
	for (DElementPattern pattern : patterns) {
	for (QName qName : pattern.getName().listNames()) {
	List<DElementPattern> dPatterns = name2patterns.get(qName);
	if (dPatterns == null) {
	dPatterns = new ArrayList<DElementPattern>();
	name2patterns.put(qName, dPatterns);
	}
	if (!dPatterns.contains(pattern)) dPatterns.add(pattern);
	}
	}

	final List<XmlElementDescriptor> result = new ArrayList<XmlElementDescriptor>();

	for (QName qName : name2patterns.keySet()) {
	final List<DElementPattern> patternList = name2patterns.get(qName);
	final XmlElementDescriptor descriptor = findDescriptor(qName, patternList);
	if (descriptor != null) {
	result.add(descriptor);
	}
	}

	return result.toArray(new XmlElementDescriptor[result.size()]);
	}

	protected XmlElementDescriptor initDescriptor(@NotNull XmlElementDescriptor descriptor) {
	return descriptor;
	}

	@Override
	@NotNull
	public XmlFile getDescriptorFile() {
	return myFile;
	}

	@Override
	public boolean isHierarhyEnabled() {
	return false;
	}

	@Override
	public synchronized PsiElement getDeclaration() {
	if (!myElement.isValid() \|\| !myFile.isValid()) {
	if (myUrl != null) {
	final VirtualFile fileByUrl = VirtualFileManager.getInstance().findFileByUrl(myUrl);
	if (fileByUrl != null) {
	final PsiFile file = myManager.findFile(fileByUrl);
	if (file instanceof XmlFile) {
	init(((XmlFile)file).getDocument());
	}
	}
	}
	}
	return myFile.isValid() ? myFile.getDocument() : null;
	}

	@Override
	@NonNls
	public String getName(PsiElement context) {
	return getName();
	}

	@Override
	@NonNls
	public String getName() {
	return getDescriptorFile().getName();
	}

	@Override
	public Object[] getDependences() {
	if (myPattern != null) {
	if (DumbService.isDumb(myElement.getProject())) {
	return new Object[] { ModificationTracker.EVER_CHANGED, ExternalResourceManager.getInstance()};
	}
	final Object[] a = { myElement, ExternalResourceManager.getInstance() };
	final PsiElementProcessor.CollectElements<XmlFile> processor = new PsiElementProcessor.CollectElements<XmlFile>();
	RelaxIncludeIndex.processForwardDependencies(myFile, processor);
	if (processor.getCollection().size() > 0) {
	return ArrayUtil.mergeArrays(a, processor.toArray());
	} else {
	return a;
	}
	}
	return new Object[]{ ModificationTracker.EVER_CHANGED };
	}

	@Override
	public synchronized void init(PsiElement element) {
	myElement = element;
	myFile = element instanceof XmlFile ? (XmlFile)element : (XmlFile)element.getContainingFile();
	myManager = myFile.getManager();

	final VirtualFile file = myFile.getVirtualFile();
	if (file != null) {
	myUrl = file.getUrl();
	}

	myPattern = RngParser.getCachedPattern(getDescriptorFile(), RngParser.DEFAULT_HANDLER);
	}

	@Override
	public void validate(@NotNull PsiElement context, @NotNull final ValidationHost host) {
	final XmlDocument doc = PsiTreeUtil.getContextOfType(context, XmlDocument.class, false);
	if (doc == null) {
	return;
	}
	final XmlTag rootTag = doc.getRootTag();
	if (rootTag == null) {
	return;
	}
	// RNG XML itself is validated by parsing it with Jing, so we don't want to schema-validate it
	if (!ApplicationLoader.RNG_NAMESPACE.equals(rootTag.getNamespace())) {
	XmlInstanceValidator.doValidation(doc, host, getDescriptorFile());
	}
	}

	//@Override
	@Override
	public XmlElementDescriptor getElementDescriptor(String localName, String namespace) {
	final QName qName = new QName(namespace, localName);
	CachedValue<XmlElementDescriptor> cachedValue = myDescriptorsMap.get(qName);
	if (cachedValue == null) {
	cachedValue =
	CachedValuesManager.getManager(myElement.getProject()).createCachedValue(new CachedValueProvider<XmlElementDescriptor>() {
	@Override
	public Result<XmlElementDescriptor> compute() {
	final XmlElementDescriptor descriptor = findRootDescriptorInner(qName);
	return descriptor != null
	? new Result<XmlElementDescriptor>(descriptor, descriptor.getDependences())
	: new Result<XmlElementDescriptor>(null, getDependences());
	}
	}, false);
	myDescriptorsMap.put(qName, cachedValue);
	}
	return cachedValue.getValue();
	}
	}