<treeStructureProvider implementation="com.jetbrains.edu.coursecreator.projectView.CCTreeStructureProvider"/>
<refactoring.elementListenerProvider implementation="com.jetbrains.edu.coursecreator.CCRefactoringElementListenerProvider"/>
<renameHandler implementation="com.jetbrains.edu.coursecreator.CCRenameHandler"/>
- <renameInputValidator implementation="com.jetbrains.edu.coursecreator.CCRenameInputValidator"/>
<refactoring.moveHandler implementation="com.jetbrains.edu.coursecreator.CCLessonMoveHandlerDelegate" order="first"/>
<refactoring.moveHandler implementation="com.jetbrains.edu.coursecreator.CCTaskMoveHandlerDelegate" order="first"/>
</extensions>
package com.jetbrains.edu.coursecreator;
-import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileAdapter;
import com.intellij.util.Function;
import com.jetbrains.edu.EduNames;
import com.jetbrains.edu.courseFormat.*;
-import com.jetbrains.edu.coursecreator.actions.CCRunTestsAction;
import org.jetbrains.annotations.NotNull;
class CCFileDeletedListener extends VirtualFileAdapter {
}
final TaskFile taskFile = CCProjectService.getInstance(myProject).getTaskFile(removedFile);
if (taskFile != null) {
- deleteAnswerFile(removedFile, taskFile);
+ deleteTaskFile(removedFile, taskFile);
return;
}
Course course = CCProjectService.getInstance(myProject).getCourse();
lesson.getTaskList().remove(task);
}
- private void deleteAnswerFile(@NotNull final VirtualFile removedAnswerFile, TaskFile taskFile) {
- ApplicationManager.getApplication().runWriteAction(new Runnable() {
- @Override
- public void run() {
- VirtualFile taskDir = removedAnswerFile.getParent();
- if (taskDir != null) {
- CCRunTestsAction.clearTestEnvironment(taskDir, myProject);
- }
- }
- });
- String name = CCProjectService.getRealTaskFileName(removedAnswerFile.getName());
+ private static void deleteTaskFile(@NotNull final VirtualFile removedTaskFile, TaskFile taskFile) {
Task task = taskFile.getTask();
if (task == null) {
return;
}
- task.getTaskFiles().remove(name);
+ task.getTaskFiles().remove(removedTaskFile.getName());
}
}
package com.jetbrains.edu.coursecreator;
-import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.components.ProjectComponent;
-import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.EditorFactory;
import com.intellij.openapi.editor.event.EditorFactoryEvent;
import com.intellij.openapi.editor.impl.EditorFactoryImpl;
-import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.fileEditor.FileEditor;
+import com.intellij.openapi.fileEditor.FileEditorManager;
import com.intellij.openapi.fileEditor.impl.text.PsiAwareTextEditorImpl;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.project.ProjectManager;
import com.jetbrains.edu.courseFormat.Course;
import org.jetbrains.annotations.NotNull;
-import java.io.IOException;
-
public class CCProjectComponent implements ProjectComponent {
- private static final Logger LOG = Logger.getInstance(CCProjectComponent.class.getName());
private final Project myProject;
private CCFileDeletedListener myListener;
final Course course = CCProjectService.getInstance(myProject).getCourse();
if (course != null) {
course.initCourse(true);
- myProject.getMessageBus().connect(myProject).subscribe(
- FileEditorManagerListener.FILE_EDITOR_MANAGER, new FileEditorManagerAdapter() {
- @Override
- public void selectionChanged(@NotNull FileEditorManagerEvent event) {
- final VirtualFile oldFile = event.getOldFile();
- if (oldFile == null) {
- return;
- }
- if (CCProjectService.getInstance(myProject).isTaskFile(oldFile)) {
- FileEditorManager.getInstance(myProject).closeFile(oldFile);
- ApplicationManager.getApplication().runWriteAction(new Runnable() {
- @Override
- public void run() {
- try {
- oldFile.delete(myProject);
- }
- catch (IOException e) {
- LOG.error(e);
- }
- }
- });
- }
- }
- });
myListener = new CCFileDeletedListener(myProject);
VirtualFileManager.getInstance().addVirtualFileListener(myListener);
final CCEditorFactoryListener editorFactoryListener = new CCEditorFactoryListener();
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.util.io.FileUtilRt;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.ui.JBColor;
import com.intellij.util.xmlb.XmlSerializerUtil;
if (task == null) {
return null;
}
- String fileName = getRealTaskFileName(virtualFile.getName());
- return task.getTaskFile(fileName);
+ return task.getTaskFile(virtualFile.getName());
}
public void drawAnswerPlaceholders(@NotNull final VirtualFile virtualFile, @NotNull final Editor editor) {
return null;
}
- public boolean isAnswerFile(VirtualFile file) {
- Task task = getTask(file);
- String fileName = getRealTaskFileName(file.getName());
- return task != null && fileName != null && task.isTaskFile(fileName);
- }
-
public boolean isTaskFile(VirtualFile file) {
Task task = getTask(file);
return task != null && task.isTaskFile(file.getName());
}
- @Nullable
- public static String getRealTaskFileName(String name) {
- String nameWithoutExtension = FileUtil.getNameWithoutExtension(name);
- String extension = FileUtilRt.getExtension(name);
- if (!nameWithoutExtension.endsWith(".answer")) {
- return null;
- }
- int nameEnd = name.indexOf(".answer");
- return name.substring(0, nameEnd) + "." + extension;
- }
-
public static boolean setCCActionAvailable(@NotNull AnActionEvent e) {
final Project project = e.getProject();
if (project == null) {
protected void elementRenamedOrMoved(@NotNull PsiElement newElement) {
if (newElement instanceof PsiFile && myElementName != null) {
PsiFile psiFile = (PsiFile)newElement;
- if (myElementName.contains(".answer")) {
- //this is task file
- renameTaskFile(psiFile, myElementName);
- }
+ tryToRenameTaskFile(psiFile, myElementName);
}
}
- private static void renameTaskFile(PsiFile file, String oldName) {
+ private static void tryToRenameTaskFile(PsiFile file, String oldName) {
final PsiDirectory taskDir = file.getContainingDirectory();
final CCProjectService service = CCProjectService.getInstance(file.getProject());
Course course = service.getCourse();
}
});
Map<String, TaskFile> taskFiles = task.getTaskFiles();
- String realOldName = CCProjectService.getRealTaskFileName(oldName);
- TaskFile taskFile = task.getTaskFile(realOldName);
- taskFiles.remove(realOldName);
- taskFiles.put(CCProjectService.getRealTaskFileName(file.getName()), taskFile);
+ TaskFile taskFile = task.getTaskFile(oldName);
+ taskFiles.remove(oldName);
+ taskFiles.put(file.getName(), taskFile);
}
@Override
+++ /dev/null
-package com.jetbrains.edu.coursecreator;
-
-import com.intellij.patterns.ElementPattern;
-import com.intellij.patterns.PlatformPatterns;
-import com.intellij.psi.PsiElement;
-import com.intellij.refactoring.rename.RenameInputValidator;
-import com.intellij.util.ProcessingContext;
-
-public class CCRenameInputValidator implements RenameInputValidator {
- @Override
- public ElementPattern<? extends PsiElement> getPattern() {
- return PlatformPatterns.psiFile();
- }
-
- @Override
- public boolean isInputValid(String newName, PsiElement element, ProcessingContext context) {
- if (!CCUtils.isAnswerFile(element)) {
- return true;
- }
- return newName.contains(".answer.");
- }
-}
import com.intellij.openapi.roots.ModuleRootManager;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileEvent;
import com.intellij.psi.PsiDirectory;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
import com.intellij.util.Function;
import com.jetbrains.edu.EduUtils;
import com.jetbrains.edu.courseFormat.Course;
public class CCUtils {
private static final Logger LOG = Logger.getInstance(CCUtils.class);
public static final String GENERATED_FILES_FOLDER = ".coursecreator";
+ public static final String TESTS = "coursecreatortests";
+ public static final String RESOURCES = "coursecreatorresources";
@Nullable
public static CCLanguageManager getStudyLanguageManager(@NotNull final Course course) {
return language == null ? null : CCLanguageManager.INSTANCE.forLanguage(language);
}
- public static boolean isAnswerFile(PsiElement element) {
- if (!(element instanceof PsiFile)) {
- return false;
- }
- VirtualFile file = ((PsiFile)element).getVirtualFile();
- return CCProjectService.getInstance(element.getProject()).isAnswerFile(file);
- }
-
/**
* This method decreases index and updates directory names of
* all tasks/lessons that have higher index than specified object
- * @param dirs directories that are used to get tasks/lessons
+ *
+ * @param dirs directories that are used to get tasks/lessons
* @param getStudyItem function that is used to get task/lesson from VirtualFile. This function can return null
- * @param threshold index is used as threshold
- * @param prefix task or lesson directory name prefix
+ * @param threshold index is used as threshold
+ * @param prefix task or lesson directory name prefix
*/
public static void updateHigherElements(VirtualFile[] dirs,
@NotNull final Function<VirtualFile, ? extends StudyItem> getStudyItem,
});
return generatedRoot.get();
}
+
+ /**
+ * @param requestor {@link VirtualFileEvent#getRequestor}
+ */
+ @Nullable
+ public static VirtualFile generateFolder(@NotNull Project project, @NotNull Module module, @Nullable Object requestor, String name) {
+ VirtualFile generatedRoot = getGeneratedFilesFolder(project, module);
+ if (generatedRoot == null) {
+ return null;
+ }
+
+ final Ref<VirtualFile> folder = new Ref<>(generatedRoot.findChild(name));
+ //need to delete old folder
+ ApplicationManager.getApplication().runWriteAction(() -> {
+ try {
+ if (folder.get() != null) {
+ folder.get().delete(requestor);
+ }
+ folder.set(generatedRoot.createChildDirectory(requestor, name));
+ }
+ catch (IOException e) {
+ LOG.info("Failed to generate folder " + name, e);
+ }
+ });
+ return folder.get();
+ }
}
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.CommonDataKeys;
import com.intellij.openapi.actionSystem.Presentation;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.jetbrains.edu.courseFormat.Task;
import com.jetbrains.edu.coursecreator.CCProjectService;
-import java.io.IOException;
-
public class CCAddAsTaskFile extends AnAction {
- private static final Logger LOG = Logger.getInstance(CCAddAsTaskFile.class);
-
@Override
public void actionPerformed(final AnActionEvent e) {
Project project = e.getProject();
return;
}
task.addTaskFile(file.getName(), task.getTaskFiles().size());
- ApplicationManager.getApplication().runWriteAction(new Runnable() {
- @Override
- public void run() {
- String name = file.getNameWithoutExtension();
- String extension = file.getExtension();
- try {
- file.rename(this, name + ".answer." + extension);
- }
- catch (IOException e1) {
- LOG.error(e1);
- }
- }
- });
}
return;
}
VirtualFile file = CommonDataKeys.VIRTUAL_FILE.getData(e.getDataContext());
- if (file == null || file.isDirectory() || CCProjectService.getInstance(project).isAnswerFile(file)) {
- presentation.setEnabledAndVisible(false);
- return;
- }
- Task task = CCProjectService.getInstance(project).getTask(file);
- if (task == null) {
+ if (file == null || file.isDirectory() || CCProjectService.getInstance(project).getTaskFile(file) != null) {
presentation.setEnabledAndVisible(false);
}
}
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.DialogWrapper;
import com.intellij.openapi.ui.Messages;
-import com.intellij.openapi.util.Ref;
import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.util.io.FileUtilRt;
import com.intellij.openapi.vfs.VfsUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.jetbrains.edu.coursecreator.CCUtils;
import com.jetbrains.edu.coursecreator.ui.CreateCourseArchiveDialog;
import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
import java.io.*;
import java.util.List;
}
final VirtualFile baseDir = project.getBaseDir();
- VirtualFile archiveFolder = getArchiveFolder(project, module);
+ VirtualFile archiveFolder = CCUtils.generateFolder(project, module, this, myZipName);
if (archiveFolder == null) {
return;
}
}
String taskFileName = entry.getKey();
EduUtils.createStudentFileFromAnswer(project, userFileDir, taskDir, taskFileName, taskFile);
- VirtualFile answerFile = userFileDir.findChild(
- FileUtilRt.getNameWithoutExtension(taskFileName) + ".answer." + FileUtilRt.getExtension(taskFileName));
- if (answerFile != null) {
- try {
- answerFile.delete(this);
- }
- catch (IOException e) {
- LOG.info(e);
- }
- }
}
}
}
}
}
- @Nullable
- private VirtualFile getArchiveFolder(@NotNull Project project, @NotNull Module module) {
- VirtualFile generatedFilesRoot = CCUtils.getGeneratedFilesFolder(project, module);
- if (generatedFilesRoot == null) {
- return null;
- }
- VirtualFile zipRoot = generatedFilesRoot.findChild(myZipName);
- final Ref<VirtualFile> archiveFolder = new Ref<>();
- ApplicationManager.getApplication().runWriteAction(new Runnable() {
- @Override
- public void run() {
- try {
- if (zipRoot != null) {
- zipRoot.delete(this);
- }
- archiveFolder.set(generatedFilesRoot.createChildDirectory(this, myZipName));
- }
- catch (IOException e) {
- LOG.error("Failed to get zip root for " + myZipName, e);
- }
- }
- });
- return archiveFolder.get();
- }
-
-
private static void resetTaskFiles(Map<TaskFile, TaskFile> savedTaskFiles) {
for (Map.Entry<TaskFile, TaskFile> entry : savedTaskFiles.entrySet()) {
entry.getKey().setAnswerPlaceholders(entry.getValue().getAnswerPlaceholders());
if (dialog.getExitCode() != OK_EXIT_CODE) {
return;
}
- final String taskFileName = dialog.getFileName();
- if (taskFileName == null) return;
+ final String name = dialog.getFileName();
+ if (name == null) return;
FileType type = dialog.getFileType();
if (type == null) {
return;
@Override
public void run() {
final FileTemplate taskTemplate = CCLanguageManager.getTaskFileTemplateForExtension(project, extension);
- final String answerFileName = taskFileName + ".answer." + extension;
+ final String taskFileName = name + "." + extension;
try {
if (taskTemplate == null) {
- VirtualFile file = taskDir.getVirtualFile().createChildData(this, answerFileName);
+ VirtualFile file = taskDir.getVirtualFile().createChildData(this, taskFileName);
ProjectView.getInstance(project).select(file, file, false);
FileEditorManager.getInstance(project).openFile(file, true);
}
else {
- final PsiElement taskFile = FileTemplateUtil.createFromTemplate(taskTemplate, answerFileName, null, taskDir);
+ final PsiElement taskFile = FileTemplateUtil.createFromTemplate(taskTemplate, taskFileName, null, taskDir);
ApplicationManager.getApplication().invokeLater(new Runnable() {
@Override
public void run() {
}
});
}
- task.addTaskFile(taskFileName + "." + extension, index);
+ task.addTaskFile(taskFileName, index);
}
catch (Exception ignored) {
}
final TaskFile taskFile = taskFileEntry.getValue();
VirtualFile file = userFileDir.findChild(name);
assert file != null;
- String answerFileName = file.getNameWithoutExtension() + ".answer." + file.getExtension();
- VirtualFile answerFile = answerFileDir.findChild(answerFileName);
- if (answerFile != null) {
- try {
- answerFile.delete(project);
- }
- catch (IOException e) {
- LOG.error(e);
- }
- }
- try {
- answerFile = userFileDir.createChildData(project, answerFileName);
- }
- catch (IOException e) {
- LOG.error(e);
- }
- if (answerFile == null) return;
-
final Document originDocument = FileDocumentManager.getInstance().getDocument(file);
if (originDocument == null) {
return;
}
- final Document document = FileDocumentManager.getInstance().getDocument(answerFile);
+ final Document document = FileDocumentManager.getInstance().getDocument(file);
if (document == null) return;
CommandProcessor.getInstance().executeCommand(project, new Runnable() {
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.util.io.FileUtilRt;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
if (taskFile == null) {
return;
}
- if (psiFile.getName().contains(".answer")) {
- presentation.setEnabledAndVisible(true);
- presentation.setText("Run tests from '" + FileUtil.getNameWithoutExtension(psiFile.getName()) + "'");
- }
+ presentation.setEnabledAndVisible(true);
+ presentation.setText("Run tests from '" + FileUtil.getNameWithoutExtension(psiFile.getName()) + "'");
}
public void actionPerformed(@NotNull AnActionEvent e) {
private static void createTaskFileForTest(@NotNull final VirtualFile taskDir, final String fileName, @NotNull final TaskFile taskFile,
@NotNull final Project project) {
- try {
- String answerFileName = FileUtil.getNameWithoutExtension(fileName) + ".answer";
- final String extension = FileUtilRt.getExtension(fileName);
- final VirtualFile answerFile = taskDir.findChild(answerFileName + "." + extension);
- if (answerFile == null) {
- LOG.debug("could not find answer file " + answerFileName);
- return;
- }
- ApplicationManager.getApplication().runWriteAction(new Runnable() {
- @Override
- public void run() {
- final FileDocumentManager documentManager = FileDocumentManager.getInstance();
- documentManager.saveAllDocuments();
- }
- });
- final VirtualFile oldTaskFile = taskDir.findChild(fileName);
- if (oldTaskFile != null) {
- oldTaskFile.delete(project);
- }
- VirtualFile copy = answerFile.copy(project, taskDir, fileName);
- EduUtils.flushWindows(taskFile, copy, false);
- createResourceFiles(answerFile, project);
- }
- catch (IOException e) {
- LOG.error(e);
+ final VirtualFile answerFile = taskDir.findChild(fileName);
+ if (answerFile == null) {
+ LOG.debug("could not find answer file " + fileName);
+ return;
}
+ ApplicationManager.getApplication().runWriteAction(new Runnable() {
+ @Override
+ public void run() {
+ final FileDocumentManager documentManager = FileDocumentManager.getInstance();
+ documentManager.saveAllDocuments();
+ }
+ });
+ EduUtils.flushWindows(taskFile, answerFile, false);
+ createResourceFiles(answerFile, project);
}
public static void clearTestEnvironment(@NotNull final VirtualFile taskDir, @NotNull final Project project) {
if (file.getName().contains(EduNames.WINDOWS_POSTFIX)) {
file.delete(project);
}
- if (CCProjectService.getInstance(project).isTaskFile(file)) {
- file.delete(project);
- }
}
}
catch (IOException e) {
}
protected abstract void executeTests(@NotNull final Project project,
- @NotNull final VirtualFile virtualFile,
- @NotNull final VirtualFile taskDir,
- @NotNull final VirtualFile testFile);
+ @NotNull final VirtualFile virtualFile,
+ @NotNull final VirtualFile taskDir,
+ @NotNull final VirtualFile testFile);
//some tests could compare task files after user modifications with initial task files
private static void createResourceFiles(@NotNull final VirtualFile file, @NotNull final Project project) {
}
}
- private static VirtualFile findOrCreateDir(@NotNull final Project project, @NotNull final VirtualFile dir, String name) throws IOException {
+ private static VirtualFile findOrCreateDir(@NotNull final Project project, @NotNull final VirtualFile dir, String name)
+ throws IOException {
VirtualFile targetDir = dir.findChild(name);
if (targetDir == null) {
targetDir = dir.createChildDirectory(project, name);
}
return targetDir;
}
-
}
import com.intellij.openapi.Disposable;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.CommonDataKeys;
+import com.intellij.openapi.actionSystem.LangDataKeys;
import com.intellij.openapi.actionSystem.Presentation;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.EditorFactory;
import com.intellij.openapi.editor.ex.EditorEx;
import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.DumbAwareAction;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.FrameWrapper;
import com.jetbrains.edu.courseFormat.Course;
import com.jetbrains.edu.courseFormat.TaskFile;
import com.jetbrains.edu.coursecreator.CCProjectService;
+import com.jetbrains.edu.coursecreator.CCUtils;
import org.jetbrains.annotations.NotNull;
import javax.swing.*;
if (!CCProjectService.setCCActionAvailable(e)) {
return;
}
+ Project project = e.getProject();
+ if (project == null) {
+ return;
+ }
Presentation presentation = e.getPresentation();
presentation.setEnabledAndVisible(false);
final PsiFile file = CommonDataKeys.PSI_FILE.getData(e.getDataContext());
- if (file != null && file.getName().contains(".answer")) {
+ if (file != null && CCProjectService.getInstance(project).getTaskFile(file.getVirtualFile()) != null) {
presentation.setEnabledAndVisible(true);
}
}
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
+ //TODO: need to rewrite this action using new GENERATED_ROOT_FOLDER
final Project project = e.getProject();
- if (project == null) {
+ Module module = LangDataKeys.MODULE.getData(e.getDataContext());
+ if (project == null || module == null) {
return;
}
final PsiFile file = CommonDataKeys.PSI_FILE.getData(e.getDataContext());
- if (file == null || !file.getName().contains(".answer")) {
- return;
- }
- final PsiDirectory taskDir = file.getContainingDirectory();
- if (taskDir == null) {
- return;
- }
- PsiDirectory lessonDir = taskDir.getParentDirectory();
- if (lessonDir == null) {
+ if (file == null) {
return;
}
final CCProjectService service = CCProjectService.getInstance(project);
if (course == null) {
return;
}
- TaskFile taskFile = service.getTaskFile(file.getVirtualFile());
+ VirtualFile virtualFile = file.getVirtualFile();
+ TaskFile taskFile = service.getTaskFile(virtualFile);
if (taskFile == null) {
return;
}
+ final PsiDirectory taskDir = file.getContainingDirectory();
+ if (taskDir == null) {
+ return;
+ }
+ PsiDirectory lessonDir = taskDir.getParentDirectory();
+ if (lessonDir == null) {
+ return;
+ }
+
+
if (taskFile.getAnswerPlaceholders().isEmpty()) {
Messages.showInfoMessage("Preview is available for task files with answer placeholders only", "No Preview for This File");
+ return;
}
final TaskFile taskFileCopy = new TaskFile();
TaskFile.copy(taskFile, taskFileCopy);
- final String taskFileName = CCProjectService.getRealTaskFileName(file.getVirtualFile().getName());
- if (taskFileName == null) {
+
+
+ VirtualFile generatedFilesFolder = CCUtils.getGeneratedFilesFolder(project, module);
+
+ if (generatedFilesFolder == null) {
return;
}
+
ApplicationManager.getApplication().runWriteAction(new Runnable() {
@Override
public void run() {
- EduUtils.createStudentFileFromAnswer(project, taskDir.getVirtualFile(), taskDir.getVirtualFile(), taskFileName, taskFileCopy);
+ EduUtils.createStudentFileFromAnswer(project, generatedFilesFolder, taskDir.getVirtualFile(), virtualFile.getName(), taskFileCopy);
}
});
- String userFileName = CCProjectService.getRealTaskFileName(file.getName());
- if (userFileName == null) {
- return;
- }
- VirtualFile userFile = taskDir.getVirtualFile().findChild(userFileName);
+ VirtualFile userFile = generatedFilesFolder.findChild(virtualFile.getName());
if (userFile == null) {
- LOG.info("Generated file " + userFileName + "was not found");
+ LOG.info("Generated file " + virtualFile.getName() + "was not found");
return;
}
final FrameWrapper showPreviewFrame = new FrameWrapper(project);
- showPreviewFrame.setTitle(userFileName);
+ showPreviewFrame.setTitle(virtualFile.getName());
LabeledEditor labeledEditor = new LabeledEditor(null);
final EditorFactory factory = EditorFactory.getInstance();
Document document = FileDocumentManager.getInstance().getDocument(userFile);
if (virtualFile == null) {
continue;
}
- if (CCProjectService.getInstance(project).isTaskFile(virtualFile)
- || virtualFile.getName().contains(EduNames.WINDOWS_POSTFIX)) {
+ if (virtualFile.getName().contains(EduNames.WINDOWS_POSTFIX)) {
continue;
}
}
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.TextRange;
import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.util.io.FileUtilRt;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.intellij.psi.PsiDirectory;
}
if (taskFile.getAnswerPlaceholders().isEmpty()) {
- String extension = FileUtilRt.getExtension(taskFileName);
- String nameWithoutExtension = FileUtilRt.getNameWithoutExtension(taskFileName);
- VirtualFile answerFile = answerFileDir.findChild(nameWithoutExtension + ".answer." + extension);
+ //do not need to replace anything, just copy
+ VirtualFile answerFile = answerFileDir.findChild(taskFileName);
if (answerFile != null) {
try {
answerFile.copy(answerFileDir, userFileDir, taskFileName);
}
file = userFileDir.findChild(taskFileName);
- assert file != null;
- String answerFileName = file.getNameWithoutExtension() + ".answer." + file.getExtension();
- VirtualFile answerFile = answerFileDir.findChild(answerFileName);
+ if (file == null) {
+ LOG.info("Failed to find task file " + taskFileName);
+ return;
+ }
+ VirtualFile answerFile = answerFileDir.findChild(taskFileName);
if (answerFile == null) {
return;
}
public void run() {
final VirtualFile taskDir = task.getTaskDir(project);
assert taskDir != null;
- EduUtils.createStudentFileFromAnswer(project, taskDir, taskDir, entry.getKey(), taskFile);
+ VirtualFile ideaDir = project.getBaseDir().findChild(".idea");
+ assert ideaDir != null;
+ EduUtils.createStudentFileFromAnswer(project, ideaDir, taskDir, entry.getKey(), taskFile);
}
});
taskFile.name = entry.getKey();
- final VirtualFile taskDirectory = task.getTaskDir(project);
- if (taskDirectory == null) return null;
- final VirtualFile file = taskDirectory.findChild(taskFile.name);
+ VirtualFile ideaDir = project.getBaseDir().findChild(".idea");
+ if (ideaDir == null) return null;
+ final VirtualFile file = ideaDir.findChild(taskFile.name);
try {
if (file != null) {
if (EduUtils.isImage(taskFile.name)) {
if (!extension.equals("py")) {
return null;
}
- return getInternalTemplateByName(project, "task.answer.py");
+ return getInternalTemplateByName(project, "task.py");
}
@Nullable
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.intellij.util.PathUtil;
-import com.jetbrains.edu.coursecreator.CCProjectService;
import com.jetbrains.python.run.PythonConfigurationType;
import com.jetbrains.python.run.PythonRunConfiguration;
import org.jetbrains.annotations.NotNull;
final PythonRunConfiguration configuration = (PythonRunConfiguration)settings.getConfiguration();
configuration.setScriptName(testFile.getPath());
configuration.setWorkingDirectory(taskDir.getPath());
- String taskFileName = CCProjectService.getRealTaskFileName(virtualFile.getName());
- if (taskFileName == null) {
- return;
- }
+ String taskFileName = virtualFile.getName();
VirtualFile userFile = taskDir.findChild(taskFileName);
if (userFile == null) {
return;