plugins/org.eclipse.wst.sse.sieditor.search/src/org/eclipse/wst/sse/sieditor/search/provider/xsd/XsdSearchQueryOperation.java

/*******************************************************************************
 * Copyright (c) 2012 SAP AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Georgi Konstantinov - initial API and implementation.
 *******************************************************************************/
package org.eclipse.wst.sse.sieditor.search.provider.xsd;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;

import org.eclipse.core.resources.IFile;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.platform.discovery.runtime.api.ISearchDestination;
import org.eclipse.platform.discovery.runtime.api.ISearchParameters;
import org.eclipse.wst.sse.sieditor.core.common.Logger;
import org.eclipse.wst.sse.sieditor.model.api.IWsdlModelRoot;
import org.eclipse.wst.sse.sieditor.model.api.IXSDModelRoot;
import org.eclipse.wst.sse.sieditor.model.impl.XSDFactory;
import org.eclipse.wst.sse.sieditor.model.xsd.api.ISchema;
import org.eclipse.wst.sse.sieditor.model.xsd.api.ISimpleType;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IStructureType;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IType;
import org.eclipse.wst.sse.sieditor.search.destinations.xsd.AllCategoriesDestination;
import org.eclipse.wst.sse.sieditor.search.destinations.xsd.XsdComplexTypesDestination;
import org.eclipse.wst.sse.sieditor.search.destinations.xsd.XsdElementDeclarationDestination;
import org.eclipse.wst.sse.sieditor.search.destinations.xsd.XsdSimpleTypesDestination;
import org.eclipse.wst.sse.sieditor.search.provider.AbstractSearchQueryOperation;
import org.eclipse.wst.sse.sieditor.search.provider.WildcardStringMatcher;
import org.eclipse.wst.sse.sieditor.search.ui.tree.FileNode;
import org.eclipse.wst.sse.sieditor.search.ui.tree.ITreeNodeWithCustomizableChildren;
import org.eclipse.wst.sse.sieditor.search.ui.tree.NamespaceNode;
import org.eclipse.wst.sse.sieditor.search.ui.tree.RootTreeNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.impl.SimpleTypeNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.impl.StructureTypeNode;
import org.eclipse.wst.sse.sieditor.ui.v2.factory.TreeNodeMapper;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.util.XSDResourceFactoryImpl;
import org.eclipse.xsd.util.XSDResourceImpl;

public class XsdSearchQueryOperation extends AbstractSearchQueryOperation {

    public XsdSearchQueryOperation(ISearchParameters searchParams) {
        super(searchParams);
    }

    @Override
    protected boolean isFileThatMayHaveTheSearchedContenet(String fileExtension) {
        if (isWsdlFileExtension(fileExtension) || isXsdFileExtension(fileExtension) || isXmlFileExtension(fileExtension)) {
            return true;
        }
        return false;
    }

    @Override
    protected void analyzeFile(RootTreeNode rootTreeNode, IFile file, FileNode fileNode) {
        TreeNodeMapper treeNodeMapper = new TreeNodeMapper();
        Collection<ISchema> schemas = getSchemasFromFile(file);
        for (ISchema schema : schemas) {
            if (isByNamespaceHierarchy() || isByFilesHierarchy()) {
                NamespaceNode namespaceNode = new NamespaceNode(schema, fileNode);
                addTypesToParentNode(schema, namespaceNode, treeNodeMapper);
                addNamespaceNodeContentToTree(rootTreeNode, fileNode, namespaceNode);
            } else {
                addTypesToParentNode(schema, rootTreeNode, treeNodeMapper);
            }
        }

    }

    private Collection<ISchema> getSchemasFromFile(IFile file) {
        Collection<ISchema> schemasInFile = new ArrayList<ISchema>();
        String fileExtension = file.getFileExtension();
        if (isXsdFileExtension(fileExtension) || isXmlFileExtension(fileExtension)) {
            ISchema schemaFromXsdFile = getSchemaFromXsdFile(file);
            if (schemaFromXsdFile != null) {
                schemasInFile.add(schemaFromXsdFile);
            }
        }

        if (isWsdlFileExtension(fileExtension) || isXmlFileExtension(fileExtension)) {
            schemasInFile.addAll(getSchemasFromWsdl(file));
        }

        return schemasInFile;
    }

    private Collection<ISchema> getSchemasFromWsdl(IFile file) {
        IWsdlModelRoot modelRoot = getWsdlModelRootForFile(file);
        return modelRoot.getDescription().getContainedSchemas();
    }

    private ISchema getSchemaFromXsdFile(IFile file) {
        Map<String, Object> extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
        Object currentXmlResourceFactoryWithLowerCase = extensionToFactoryMap.get(XML_FILE_EXTENSION.toLowerCase());
        Object currentXmlResourceFactoryWithUpperCase = extensionToFactoryMap.get(XML_FILE_EXTENSION.toUpperCase());
        Object currentXsdResourceFactoryWithUpperCase = extensionToFactoryMap.get(XSD_FILE_EXTENSION.toUpperCase());
        try {
            extensionToFactoryMap.put(XML_FILE_EXTENSION.toLowerCase(), new XSDResourceFactoryImpl());
            extensionToFactoryMap.put(XML_FILE_EXTENSION.toUpperCase(), new XSDResourceFactoryImpl());
            extensionToFactoryMap.put(XSD_FILE_EXTENSION.toUpperCase(), new XSDResourceFactoryImpl());

            ResourceSet resourceSet = new ResourceSetImpl();

            XSDResourceImpl resource = (XSDResourceImpl) resourceSet.getResource(createFileUri(file), true);
            XSDSchema schema = resource.getSchema();
            IXSDModelRoot modelRoot = XSDFactory.getInstance().createXSDModelRoot(schema);
            return modelRoot.getSchema();
        } catch (Exception e) {
            Logger.logWarning("Failed to read file", e); //$NON-NLS-1$
        } finally {
            extensionToFactoryMap.put(XML_FILE_EXTENSION.toLowerCase(), currentXmlResourceFactoryWithLowerCase);
            extensionToFactoryMap.put(XML_FILE_EXTENSION.toUpperCase(), currentXmlResourceFactoryWithUpperCase);
            extensionToFactoryMap.put(XSD_FILE_EXTENSION.toUpperCase(), currentXsdResourceFactoryWithUpperCase);
        }
        return null;
    }

    private void addTypesToParentNode(ISchema schema, ITreeNodeWithCustomizableChildren parent, TreeNodeMapper treeNodeMapper) {
        Collection<IType> containedTypes = schema.getAllContainedTypes();
        for (IType type : containedTypes) {
            if (!WildcardStringMatcher.matches(searchParams.getKeywordString(), type.getName())) {
                continue;
            }

            ISearchDestination searchDestination = searchParams.getSearchDestination();

            if (type instanceof IStructureType) {
                IStructureType structureType = (IStructureType) type;
                if (structureType.isElement()
                        && (searchDestination instanceof XsdElementDeclarationDestination || searchDestination instanceof AllCategoriesDestination)) {
                    parent.addChild(new StructureTypeNode(type, parent, treeNodeMapper));
                }

                if (!structureType.isElement()
                        && (searchDestination instanceof XsdComplexTypesDestination || searchDestination instanceof AllCategoriesDestination)) {
                    parent.addChild(new StructureTypeNode(type, parent, treeNodeMapper));
                }

            }

            if (type instanceof ISimpleType) {
                if (searchDestination instanceof XsdSimpleTypesDestination
                        || searchDestination instanceof AllCategoriesDestination) {
                    parent.addChild(new SimpleTypeNode(type, parent));
                }
            }
        }
    }

}