public static PsiFile createFromTemplate(
final PsiDirectory directory,
final String name,
String fileName,
String templateName,
@NonNls String... parameters)
throws IncorrectOperationException {
log.debug("createFromTemplate: dir:" + directory + ", filename: " + fileName);
final FileTemplate template = FileTemplateManager.getInstance().getTemplate(templateName);
Properties properties =
new Properties(FileTemplateManager.getInstance().getDefaultProperties());
String text;
try {
text = template.getText(properties);
} catch (Exception e) {
throw new RuntimeException(
"Unable to load template for "
+ FileTemplateManager.getInstance().internalTemplateToSubject(templateName),
e);
}
final PsiFileFactory factory = PsiFileFactory.getInstance(directory.getProject());
log.debug("Create file from text");
final PsiFile file = factory.createFileFromText(fileName, MoonFileType.MOON_FILE_TYPE, text);
log.debug("Adding file to directory");
return (PsiFile) directory.add(file);
}
@Override
protected void buildDialog(
final Project project, PsiDirectory directory, CreateFileFromTemplateDialog.Builder builder) {
builder
.setTitle(JavaCoreBundle.message("action.create.new.class"))
.addKind("Class", PlatformIcons.CLASS_ICON, JavaTemplateUtil.INTERNAL_CLASS_TEMPLATE_NAME)
.addKind(
"Interface",
PlatformIcons.INTERFACE_ICON,
JavaTemplateUtil.INTERNAL_INTERFACE_TEMPLATE_NAME);
Module module = ModuleUtilCore.findModuleForPsiElement(directory);
assert module != null;
JavaModuleExtensionImpl moduleExtension =
ModuleRootManager.getInstance(module).getExtension(JavaModuleExtensionImpl.class);
assert moduleExtension != null;
if (moduleExtension.getLanguageLevel().isAtLeast(LanguageLevel.JDK_1_5)) {
builder.addKind(
"Enum", PlatformIcons.ENUM_ICON, JavaTemplateUtil.INTERNAL_ENUM_TEMPLATE_NAME);
builder.addKind(
"Annotation",
PlatformIcons.ANNOTATION_TYPE_ICON,
JavaTemplateUtil.INTERNAL_ANNOTATION_TYPE_TEMPLATE_NAME);
}
for (FileTemplate template : FileTemplateManager.getInstance().getAllTemplates()) {
final JavaCreateFromTemplateHandler handler = new JavaCreateFromTemplateHandler();
if (handler.handlesTemplate(template) && JavaCreateFromTemplateHandler.canCreate(directory)) {
builder.addKind(template.getName(), JavaFileType.INSTANCE.getIcon(), template.getName());
}
}
builder.setValidator(
new InputValidatorEx() {
@Override
public String getErrorText(String inputString) {
if (inputString.length() > 0
&& !JavaPsiFacade.getInstance(project)
.getNameHelper()
.isQualifiedName(inputString)) {
return "This is not a valid Java qualified name";
}
return null;
}
@Override
public boolean checkInput(String inputString) {
return true;
}
@Override
public boolean canClose(String inputString) {
return !StringUtil.isEmptyOrSpaces(inputString) && getErrorText(inputString) == null;
}
});
}
public CreateFromTemplateAction(FileTemplate template) {
super(
template.getName(),
null,
FileTypeManagerEx.getInstanceEx()
.getFileTypeByExtension(template.getExtension())
.getIcon());
myTemplate = template;
}
private void registerScalaScriptTemplate() {
String templateText = ScalaBundle.message("template.file.text");
if (FileTemplateManager.getInstance().getTemplate(SCALA_FILE_TEMPLATE) == null) {
FileTemplate scalaTemplate =
FileTemplateManager.getInstance()
.addTemplate(
SCALA_FILE_TEMPLATE, ScalaFileType.SCALA_FILE_TYPE.getDefaultExtension());
((FileTemplateImpl) scalaTemplate).setInternal(true);
scalaTemplate.setText(templateText);
}
}
private static String getText(final String templateName, @Nullable Project project)
throws IOException {
final FileTemplateManager templateManager =
project == null
? FileTemplateManager.getDefaultInstance()
: FileTemplateManager.getInstance(project);
final FileTemplate template = templateManager.getJ2eeTemplate(templateName);
if (template == null) {
return "";
}
return template.getText(templateManager.getDefaultProperties());
}
public void testSurroundWithTryCatchProperties() {
FileTemplate template =
FileTemplateManager.getInstance(getProject())
.getCodeTemplate(JavaTemplateUtil.TEMPLATE_CATCH_BODY);
String old = template.getText();
template.setText("// ${DS} \n" + "${EXCEPTION}.printStackTrace();");
try {
doTest(new JavaWithTryCatchSurrounder());
} finally {
template.setText(old);
}
}
@Override
public void setupRootModel(ModifiableRootModel model) throws ConfigurationException {
String contentPath = getContentEntryPath();
if (StringUtil.isEmpty(contentPath)) {
return;
}
File contentRootDir = new File(contentPath);
FileUtilRt.createDirectory(contentRootDir);
LocalFileSystem fileSystem = LocalFileSystem.getInstance();
VirtualFile vContentRootDir = fileSystem.refreshAndFindFileByIoFile(contentRootDir);
if (vContentRootDir == null) {
return;
}
model.addContentEntry(vContentRootDir);
VirtualFile configFile = getExternalProjectConfigFile(vContentRootDir);
if (configFile != null && myTemplateConfigName != null) {
FileTemplateManager manager = FileTemplateManager.getInstance();
FileTemplate template = manager.getInternalTemplate(myTemplateConfigName);
try {
VfsUtil.saveText(configFile, template.getText());
} catch (IOException e) {
LOG.warn(
String.format(
"Unexpected exception on applying template %s config",
myExternalSystemId.getReadableName()),
e);
throw new ConfigurationException(
e.getMessage(),
String.format(
"Can't apply %s template config text", myExternalSystemId.getReadableName()));
}
}
AbstractExternalSystemSettings settings =
ExternalSystemApiUtil.getSettings(model.getProject(), myExternalSystemId);
S externalProjectSettings = createSettings();
if (myExternalProjectSettingsControl != null) {
String errorMessage = myExternalProjectSettingsControl.apply(externalProjectSettings);
myExternalProjectSettingsControl.disposeUIResources();
if (errorMessage != null) {
throw new ConfigurationException(errorMessage);
}
}
//noinspection unchecked
settings.linkProject(externalProjectSettings);
}
@SuppressWarnings("DialogTitleCapitalization")
@Nullable
public static PsiFile createFileFromTemplate(
@SuppressWarnings("NullableProblems") @NotNull String name,
@NotNull FileTemplate template,
@NotNull PsiDirectory dir,
@Nullable String defaultTemplateProperty) {
// TODO: Do we *have* to hack the IntelliJ source?
// This is a roughly a copy/paste then slight adaptation from the IntelliJ definition of this
// method.
// We can't override it directly, and more importantly we can't override its call to
// FileTemplateUtil.createFromTemplate()
List<String> pathItems = FileUtil.getPathFromSourceRoot(dir.getProject(), dir.getVirtualFile());
// modulePrefix is the empty string if the module is either in the top
// level directory or one of the subdirectories start with a lower-case
// letter.
final String modulePrefix =
pathItems == null || invalidPathItems(pathItems) ? "" : StringUtil.join(pathItems, ".");
// Adapted from super definition.
CreateFileAction.MkDirs mkdirs = new CreateFileAction.MkDirs(name, dir);
name = mkdirs.newName;
dir = mkdirs.directory;
PsiElement element;
Project project = dir.getProject();
try {
// Patch props with custom property.
Properties props = FileTemplateManager.getInstance().getDefaultProperties(project);
props.setProperty(
"HASKELL_MODULE_NAME", modulePrefix.isEmpty() ? name : modulePrefix + '.' + name);
element = FileTemplateUtil.createFromTemplate(template, name, props, dir);
final PsiFile psiFile = element.getContainingFile();
final VirtualFile virtualFile = psiFile.getVirtualFile();
if (virtualFile != null) {
FileEditorManager.getInstance(project).openFile(virtualFile, true);
if (defaultTemplateProperty != null) {
PropertiesComponent.getInstance(project)
.setValue(defaultTemplateProperty, template.getName());
}
return psiFile;
}
} catch (ParseException e) {
Messages.showErrorDialog(
project,
"Error parsing Velocity template: " + e.getMessage(),
"Create File from Template");
return null;
} catch (IncorrectOperationException e) {
throw e;
} catch (Exception e) {
LOG.error(e);
}
return null;
}
@Nullable
public static VirtualFile createFileFromTemplate(
final String templateName, final VirtualFile parent, final String fileName) {
parent.refresh(false, false);
final FileTemplate template = FileTemplateManager.getInstance().getJ2eeTemplate(templateName);
try {
final String text =
template.getText(FileTemplateManager.getInstance().getDefaultProperties());
VirtualFile file = parent.findChild(fileName);
if (file == null) {
file = parent.createChildData(AppEngineSupportProvider.class, fileName);
}
VfsUtil.saveText(file, text);
return file;
} catch (IOException e) {
LOG.error(e);
return null;
}
}
private static void runOrApplyFileTemplate(
Project project,
VirtualFile file,
String templateName,
Properties properties,
Properties conditions,
boolean interactive)
throws IOException {
FileTemplateManager manager = FileTemplateManager.getInstance();
FileTemplate fileTemplate = manager.getJ2eeTemplate(templateName);
Properties allProperties = manager.getDefaultProperties(project);
if (!interactive) {
allProperties.putAll(properties);
}
allProperties.putAll(conditions);
String text = fileTemplate.getText(allProperties);
Pattern pattern = Pattern.compile("\\$\\{(.*)\\}");
Matcher matcher = pattern.matcher(text);
StringBuffer builder = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(builder, "\\$" + matcher.group(1).toUpperCase() + "\\$");
}
matcher.appendTail(builder);
text = builder.toString();
TemplateImpl template =
(TemplateImpl) TemplateManager.getInstance(project).createTemplate("", "", text);
for (int i = 0; i < template.getSegmentsCount(); i++) {
if (i == template.getEndSegmentNumber()) continue;
String name = template.getSegmentName(i);
String value = "\"" + properties.getProperty(name, "") + "\"";
template.addVariable(name, value, value, true);
}
if (interactive) {
OpenFileDescriptor descriptor = new OpenFileDescriptor(project, file);
Editor editor = FileEditorManager.getInstance(project).openTextEditor(descriptor, true);
editor.getDocument().setText("");
TemplateManager.getInstance(project).startTemplate(editor, template);
} else {
VfsUtil.saveText(file, template.getTemplateText());
}
}
@Override
public boolean isModified() {
if (myModified) {
return true;
}
String name = (myTemplate == null) ? "" : myTemplate.getName();
String extension = (myTemplate == null) ? "" : myTemplate.getExtension();
if (!Comparing.equal(name, myNameField.getText())) {
return true;
}
if (!Comparing.equal(extension, myExtensionField.getText())) {
return true;
}
if (myTemplate != null) {
if (myTemplate.isReformatCode() != myAdjustBox.isSelected()) {
return true;
}
}
return false;
}
private EditorHighlighter createHighlighter() {
if (myTemplate != null && myProject != null && myVelocityFileType != FileTypes.UNKNOWN) {
return EditorHighlighterFactory.getInstance()
.createEditorHighlighter(
myProject, new LightVirtualFile("aaa." + myTemplate.getExtension() + ".ft"));
}
FileType fileType = null;
if (myTemplate != null) {
fileType = FileTypeManager.getInstance().getFileTypeByExtension(myTemplate.getExtension());
}
if (fileType == null) {
fileType = FileTypes.PLAIN_TEXT;
}
SyntaxHighlighter originalHighlighter =
SyntaxHighlighterFactory.getSyntaxHighlighter(fileType, null, null);
if (originalHighlighter == null) originalHighlighter = new PlainSyntaxHighlighter();
return new LexerEditorHighlighter(
new TemplateHighlighter(originalHighlighter),
EditorColorsManager.getInstance().getGlobalScheme());
}
@Override
public void apply() throws ConfigurationException {
if (myTemplate != null) {
myTemplate.setText(myTemplateEditor.getDocument().getText());
String name = myNameField.getText();
String extension = myExtensionField.getText();
int lastDotIndex = extension.lastIndexOf(".");
if (lastDotIndex >= 0) {
name += extension.substring(0, lastDotIndex + 1);
extension = extension.substring(lastDotIndex + 1);
}
if (name.length() == 0 || !isValidFilename(name + "." + extension)) {
throw new ConfigurationException(
IdeBundle.message("error.invalid.template.file.name.or.extension"));
}
myTemplate.setName(name);
myTemplate.setExtension(extension);
myTemplate.setReformatCode(myAdjustBox.isSelected());
}
myModified = false;
}
private static void saveFile(
@NotNull VirtualFile file, @NotNull String templateName, @Nullable Map templateAttributes)
throws ConfigurationException {
FileTemplateManager manager = FileTemplateManager.getInstance();
FileTemplate template = manager.getInternalTemplate(templateName);
try {
VfsUtil.saveText(
file,
templateAttributes != null ? template.getText(templateAttributes) : template.getText());
} catch (IOException e) {
LOG.warn(
String.format(
"Unexpected exception on applying template %s config",
GradleConstants.SYSTEM_ID.getReadableName()),
e);
throw new ConfigurationException(
e.getMessage(),
String.format(
"Can't apply %s template config text", GradleConstants.SYSTEM_ID.getReadableName()));
}
}
@Override
public void reset() {
final String text = (myTemplate == null) ? "" : myTemplate.getText();
String name = (myTemplate == null) ? "" : myTemplate.getName();
String extension = (myTemplate == null) ? "" : myTemplate.getExtension();
String description = (myTemplate == null) ? "" : myTemplate.getDescription();
if ((description.length() == 0) && (myDefaultDescriptionUrl != null)) {
try {
description = UrlUtil.loadText(myDefaultDescriptionUrl);
} catch (IOException e) {
LOG.error(e);
}
}
EditorFactory.getInstance().releaseEditor(myTemplateEditor);
myFile = createFile(text, name);
myTemplateEditor = createEditor();
boolean adjust = (myTemplate != null) && myTemplate.isReformatCode();
myNameField.setText(name);
myExtensionField.setText(extension);
myAdjustBox.setSelected(adjust);
String desc = description.length() > 0 ? description : EMPTY_HTML;
// [myakovlev] do not delete these stupid lines! Or you get Exception!
myDescriptionComponent.setContentType(CONTENT_TYPE_PLAIN);
myDescriptionComponent.setEditable(true);
myDescriptionComponent.setText(desc);
myDescriptionComponent.setContentType(UIUtil.HTML_MIME);
myDescriptionComponent.setText(desc);
myDescriptionComponent.setCaretPosition(0);
myDescriptionComponent.setEditable(false);
myDescriptionPanel.setVisible(StringUtil.isNotEmpty(description));
myNameField.setEditable((myTemplate != null) && (!myTemplate.isDefault()));
myExtensionField.setEditable((myTemplate != null) && (!myTemplate.isDefault()));
myModified = false;
}
private Editor createEditor() {
EditorFactory editorFactory = EditorFactory.getInstance();
Document doc =
myFile == null
? editorFactory.createDocument(myTemplate == null ? "" : myTemplate.getText())
: PsiDocumentManager.getInstance(myFile.getProject()).getDocument(myFile);
Editor editor =
myProject == null
? editorFactory.createEditor(doc)
: editorFactory.createEditor(doc, myProject);
EditorSettings editorSettings = editor.getSettings();
editorSettings.setVirtualSpace(false);
editorSettings.setLineMarkerAreaShown(false);
editorSettings.setIndentGuidesShown(false);
editorSettings.setLineNumbersShown(false);
editorSettings.setFoldingOutlineShown(false);
editorSettings.setAdditionalColumnsCount(3);
editorSettings.setAdditionalLinesCount(3);
EditorColorsScheme scheme = editor.getColorsScheme();
scheme.setColor(EditorColors.CARET_ROW_COLOR, null);
editor
.getDocument()
.addDocumentListener(
new DocumentAdapter() {
@Override
public void documentChanged(DocumentEvent e) {
onTextChanged();
}
});
((EditorEx) editor).setHighlighter(createHighlighter());
mySplitter.setFirstComponent(editor.getComponent());
return editor;
}