package org.erlide.ui.templates;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.templates.ContextTypeRegistry;
import org.eclipse.jface.text.templates.Template;
import org.eclipse.jface.text.templates.TemplateException;
import org.eclipse.jface.text.templates.persistence.TemplatePersistenceData;
import org.eclipse.jface.text.templates.persistence.TemplateReaderWriter;
import org.eclipse.ui.editors.text.templates.ContributionTemplateStore;
import org.erlide.ui.internal.ErlideUIPlugin;
public class ErlideContributionTemplateStore extends ContributionTemplateStore {
/**
* Creates a new template store.
*
* @param store
* the preference store in which to store custom templates under
* <code>key</code>
* @param key
* the key into <code>store</code> where to store custom
* templates
*/
public ErlideContributionTemplateStore(final IPreferenceStore store,
final String key) {
super(store, key);
}
/**
* Creates a new template store with a context type registry. Only templates
* that specify a context type contained in the registry will be loaded by
* this store if the registry is not <code>null</code>.
*
* @param registry
* a context type registry, or <code>null</code> if all templates
* should be loaded
* @param store
* the preference store in which to store custom templates under
* <code>key</code>
* @param key
* the key into <code>store</code> where to store custom
* templates
*/
public ErlideContributionTemplateStore(final ContextTypeRegistry registry,
final IPreferenceStore store, final String key) {
super(registry, store, key);
}
/**
* Loads the templates contributed via the templates extension point.
*
* @throws IOException
* {@inheritDoc}
*/
@Override
protected void loadContributedTemplates() throws IOException {
super.loadContributedTemplates();
final String erlideTemplates = System.getProperty("erlide.templates");
if (erlideTemplates != null) {
final String[] l = erlideTemplates.split(";");
final Collection<TemplatePersistenceData> templates = new ArrayList<>();
readIncludedTemplates(templates, l);
for (final TemplatePersistenceData data : templates) {
add(data);
}
}
}
private void readIncludedTemplates(
final Collection<TemplatePersistenceData> templates, final String[] files) {
for (final String file : files) {
if (file != null) {
try (final InputStream input = new FileInputStream(new File(file));
InputStream stream = new BufferedInputStream(input)) {
final TemplateReaderWriter reader = new TemplateReaderWriter();
final TemplatePersistenceData[] datas = reader.read(stream, null);
for (final TemplatePersistenceData data : datas) {
if (validateTemplate(data.getTemplate())) {
templates.add(data);
}
}
} catch (final IOException x) {
}
}
}
}
private boolean validateTemplate(final Template template) {
final String contextTypeId = template.getContextTypeId();
if (!contextExists(contextTypeId)) {
return false;
}
if (getRegistry() != null) {
try {
getRegistry().getContextType(contextTypeId)
.validate(template.getPattern());
} catch (final TemplateException e) {
ErlideUIPlugin
.logErrorMessage("bad formed template: " + template.getName());
ErlideUIPlugin.log(e);
return false;
}
}
return true;
}
/**
* Returns <code>true</code> if a context type id specifies a valid context
* type or if no context type registry is present.
*
* @param contextTypeId
* the context type id to look for
* @return <code>true</code> if the context type specified by the id is
* present in the context type registry, or if no registry is
* specified
*/
private boolean contextExists(final String contextTypeId) {
return contextTypeId != null && (getRegistry() == null
|| getRegistry().getContextType(contextTypeId) != null);
}
}