</extensions>
<extensions defaultExtensionNs="Edu">
- <StudyLanguageManager implementationClass="com.jetbrains.edu.coursecreator.PyStudyLanguageManager" language="Python"/>
+ <CCLanguageManager implementationClass="com.jetbrains.edu.coursecreator.PyCCLanguageManager" language="Python"/>
</extensions>
<application-components>
import java.io.File;
-public class PyStudyLanguageManager implements StudyLanguageManager {
+public class PyCCLanguageManager implements CCLanguageManager {
@Nullable
@Override
public String getDefaultTaskFileExtension() {
</extensions>
<extensions defaultExtensionNs="Edu">
<StudyExecutor implementationClass="com.jetbrains.edu.learning.PyStudyExecutor" language="Python"/>
+ <StudyLanguageManager implementationClass="com.jetbrains.edu.learning.PyStudyLanguageManager" language="Python"/>
</extensions>
<actions>
<action id="WelcomeScreen.PythonIntro" class="com.jetbrains.edu.learning.actions.PyStudyIntroductionCourseAction"
@NotNull final String sdkPath,
@NotNull final Task currentTask) {
if (!currentTask.getUserTests().isEmpty()) {
- cmd.addParameter(new File(project.getBaseDir().getPath(), StudyNames.USER_TESTER).getPath());
- cmd.addParameter(sdkPath);
- cmd.addParameter(filePath);
+ StudyLanguageManager manager = StudyUtils.getLanguageManager(currentTask.getLesson().getCourse());
+ if (manager != null) {
+ cmd.addParameter(new File(project.getBaseDir().getPath(), manager.getUserTester()).getPath());
+ cmd.addParameter(sdkPath);
+ cmd.addParameter(filePath);
+ }
}
else {
cmd.addParameter(filePath);
--- /dev/null
+package com.jetbrains.edu.learning;
+
+import org.jetbrains.annotations.NotNull;
+
+public class PyStudyLanguageManager implements StudyLanguageManager {
+
+ @NotNull
+ @Override
+ public String getTestFileName() {
+ return "tests.py";
+ }
+
+ @NotNull
+ @Override
+ public String getTestHelperFileName() {
+ return "test_helper.py";
+ }
+
+ @NotNull
+ @Override
+ public String getUserTester() {
+ return "user_tester.py";
+ }
+}
import com.intellij.execution.ExecutionException;
import com.intellij.execution.configurations.GeneralCommandLine;
+import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.module.ModuleManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.projectRoots.Sdk;
public class PyStudyTestRunner extends StudyTestRunner {
private static final String PYTHONPATH = "PYTHONPATH";
+ private static final Logger LOG = Logger.getInstance(PyStudyTestRunner.class.getName());
PyStudyTestRunner(@NotNull final Task task, @NotNull final VirtualFile taskDir) {
super(task, taskDir);
public Process createCheckProcess(@NotNull final Project project, @NotNull final String executablePath) throws ExecutionException {
final Sdk sdk = PythonSdkType.findPythonSdk(ModuleManager.getInstance(project).getModules()[0]);
- final File testRunner = new File(myTaskDir.getPath(), myTask.getTestFile());
+ Course course = myTask.getLesson().getCourse();
+ StudyLanguageManager manager = StudyUtils.getLanguageManager(course);
+ if (manager == null) {
+ LOG.info("Language manager is null for " + course.getLanguageById().getDisplayName());
+ return null;
+ }
+ final File testRunner = new File(myTaskDir.getPath(), manager.getTestFileName());
final GeneralCommandLine commandLine = new GeneralCommandLine();
commandLine.withWorkDirectory(myTaskDir.getPath());
final Map<String, String> env = commandLine.getEnvironment();
if (pythonPath != null) {
commandLine.setExePath(pythonPath);
commandLine.addParameter(testRunner.getPath());
- final Course course = StudyTaskManager.getInstance(project).getCourse();
- assert course != null;
File resourceFile = new File(course.getCourseDirectory());
commandLine.addParameter(resourceFile.getPath());
commandLine.addParameter(FileUtil.toSystemDependentName(executablePath));
</project-components>
<extensionPoints>
- <extensionPoint qualifiedName="Edu.StudyLanguageManager" beanClass="com.intellij.lang.LanguageExtensionPoint">
+ <extensionPoint qualifiedName="Edu.CCLanguageManager" beanClass="com.intellij.lang.LanguageExtensionPoint">
</extensionPoint>
</extensionPoints>
import java.io.File;
-public interface StudyLanguageManager {
- LanguageExtension<StudyLanguageManager> INSTANCE = new LanguageExtension<StudyLanguageManager>("Edu.StudyLanguageManager");
+public interface CCLanguageManager {
+ LanguageExtension<CCLanguageManager> INSTANCE = new LanguageExtension<CCLanguageManager>("Edu.CCLanguageManager");
@Nullable
String getDefaultTaskFileExtension();
}
@Nullable
- public static StudyLanguageManager getStudyLanguageManager(@NotNull final Course course) {
+ public static CCLanguageManager getStudyLanguageManager(@NotNull final Course course) {
Language language = Language.findLanguageByID(course.getLanguage());
- return language == null ? null : StudyLanguageManager.INSTANCE.forLanguage(language);
+ return language == null ? null : CCLanguageManager.INSTANCE.forLanguage(language);
}
}
import com.jetbrains.edu.coursecreator.CCDocumentListener;
import com.jetbrains.edu.coursecreator.CCProjectService;
import com.jetbrains.edu.coursecreator.CCUtils;
-import com.jetbrains.edu.coursecreator.StudyLanguageManager;
+import com.jetbrains.edu.coursecreator.CCLanguageManager;
import com.jetbrains.edu.coursecreator.format.*;
import com.jetbrains.edu.coursecreator.ui.CreateCourseArchiveDialog;
import org.jetbrains.annotations.NotNull;
try {
File zipFile = new File(myLocationDir, myZipName + ".zip");
ZipOutputStream zos = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(zipFile)));
- final StudyLanguageManager manager = CCUtils.getStudyLanguageManager(course);
+ final CCLanguageManager manager = CCUtils.getStudyLanguageManager(course);
for (Map.Entry<String, Lesson> entry : lessons.entrySet()) {
final VirtualFile lessonDir = baseDir.findChild(entry.getKey());
if (lessonDir == null) continue;
import com.intellij.ide.util.DirectoryChooserUtil;
import com.intellij.ide.util.DirectoryUtil;
import com.intellij.ide.util.EditorHelper;
-import com.intellij.lang.Language;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.CommonDataKeys;
import com.intellij.openapi.actionSystem.LangDataKeys;
import com.intellij.psi.PsiDirectory;
import com.intellij.psi.PsiElement;
import com.intellij.util.PlatformIcons;
+import com.jetbrains.edu.coursecreator.CCLanguageManager;
import com.jetbrains.edu.coursecreator.CCProjectService;
import com.jetbrains.edu.coursecreator.CCUtils;
-import com.jetbrains.edu.coursecreator.StudyLanguageManager;
import com.jetbrains.edu.coursecreator.format.Course;
import com.jetbrains.edu.coursecreator.format.Lesson;
import com.jetbrains.edu.coursecreator.format.Task;
public void run() {
final PsiDirectory taskDirectory = DirectoryUtil.createSubdirectories("task" + (size + 1), lessonDir, "\\/");
if (taskDirectory != null) {
- Language language = Language.findLanguageByID(course.getLanguage());
- if (language == null) {
+ CCLanguageManager manager = CCUtils.getStudyLanguageManager(course);
+ if (manager == null) {
return;
}
- final StudyLanguageManager studyLanguageManager = StudyLanguageManager.INSTANCE.forLanguage(language);
- CCUtils.markDirAsSourceRoot(taskDirectory.getVirtualFile(), project);
+ CCUtils.markDirAsSourceRoot(taskDirectory.getVirtualFile(), project);
final Task task = new Task(taskName);
task.setIndex(size + 1);
lesson.addTask(task, taskDirectory);
- createFromTemplateAndOpen(taskDirectory, studyLanguageManager.getTestsTemplate(project), view);
+ createFromTemplateAndOpen(taskDirectory, manager.getTestsTemplate(project), view);
createFromTemplateAndOpen(taskDirectory, FileTemplateManager.getInstance(project).getInternalTemplate("task.html"), view);
- String defaultExtension = studyLanguageManager.getDefaultTaskFileExtension();
+ String defaultExtension = manager.getDefaultTaskFileExtension();
if (defaultExtension != null) {
- FileTemplate taskFileTemplate = studyLanguageManager.getTaskFileTemplateForExtension(project,
+ FileTemplate taskFileTemplate = manager.getTaskFileTemplateForExtension(project,
defaultExtension);
createFromTemplateAndOpen(taskDirectory, taskFileTemplate, view);
if (taskFileTemplate != null) {
import com.intellij.psi.PsiElement;
import com.jetbrains.edu.coursecreator.CCProjectService;
import com.jetbrains.edu.coursecreator.CCUtils;
-import com.jetbrains.edu.coursecreator.StudyLanguageManager;
+import com.jetbrains.edu.coursecreator.CCLanguageManager;
import com.jetbrains.edu.coursecreator.format.Course;
import com.jetbrains.edu.coursecreator.format.Lesson;
import com.jetbrains.edu.coursecreator.format.Task;
if (type == null) {
return;
}
- final StudyLanguageManager studyLanguageManager = CCUtils.getStudyLanguageManager(course);
- if (studyLanguageManager == null) {
+ final CCLanguageManager CCLanguageManager = CCUtils.getStudyLanguageManager(course);
+ if (CCLanguageManager == null) {
return;
}
final String extension = type.getDefaultExtension();
ApplicationManager.getApplication().runWriteAction(new Runnable() {
@Override
public void run() {
- final FileTemplate taskTemplate = studyLanguageManager.getTaskFileTemplateForExtension(project, extension);
+ final FileTemplate taskTemplate = CCLanguageManager.getTaskFileTemplateForExtension(project, extension);
final String answerFileName = taskFileName + ".answer." + extension;
try {
if (taskTemplate == null) {
import com.intellij.util.containers.HashMap;
import com.jetbrains.edu.coursecreator.CCProjectService;
import com.jetbrains.edu.coursecreator.CCUtils;
-import com.jetbrains.edu.coursecreator.StudyLanguageManager;
+import com.jetbrains.edu.coursecreator.CCLanguageManager;
import com.jetbrains.edu.coursecreator.format.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
clearTestEnvironment(taskDir, project);
for (final Map.Entry<String, TaskFile> entry : task.getTaskFiles().entrySet()) {
final String name = entry.getKey();
- StudyLanguageManager manager = CCUtils.getStudyLanguageManager(course);
+ CCLanguageManager manager = CCUtils.getStudyLanguageManager(course);
if (manager == null) {
return;
}
import com.intellij.ui.ListScrollingUtil;
import com.intellij.ui.components.JBList;
import com.jetbrains.edu.coursecreator.CCUtils;
-import com.jetbrains.edu.coursecreator.StudyLanguageManager;
+import com.jetbrains.edu.coursecreator.CCLanguageManager;
import com.jetbrains.edu.coursecreator.format.Course;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
}
}.installOn(myList);
- StudyLanguageManager manager = CCUtils.getStudyLanguageManager(myCourse);
+ CCLanguageManager manager = CCUtils.getStudyLanguageManager(myCourse);
if (manager != null) {
String extension = manager.getDefaultTaskFileExtension();
ListScrollingUtil.selectItem(myList, FileTypeManager.getInstance().getFileTypeByExtension(extension != null ? extension : "txt"));
<extensionPoints>
<extensionPoint qualifiedName="Edu.StudyExecutor" beanClass="com.intellij.lang.LanguageExtensionPoint"/>
+ <extensionPoint qualifiedName="Edu.StudyLanguageManager" beanClass="com.intellij.lang.LanguageExtensionPoint"/>
</extensionPoints>
<actions>
--- /dev/null
+package com.jetbrains.edu.learning;
+
+import com.intellij.lang.LanguageExtension;
+import org.jetbrains.annotations.NotNull;
+
+public interface StudyLanguageManager {
+ LanguageExtension<StudyLanguageManager> INSTANCE = new LanguageExtension<StudyLanguageManager>("Edu.StudyLanguageManager");
+
+ @NotNull
+ String getTestFileName();
+
+ @NotNull
+ String getTestHelperFileName();
+
+ @NotNull
+ String getUserTester();
+}
@NonNls
public class StudyNames {
public static final String TASK_HTML = "task.html";
- public static final String TASK_TESTS = "tests.py";
public static final String LESSON = "lesson";
- public static final String TEST_HELPER = "test_helper.py";
- public static final String USER_TESTER = "user_tester.py";
public static final String LESSON_DIR = "lesson";
public static final String TEST_TAB_NAME = "test";
public static final String USER_TEST_INPUT = "input";
LOG.error("ERROR copying file " + name);
}
}
- final File testsFile = new File(taskDirectory, "tests.py");
+ StudyLanguageManager languageManager = StudyUtils.getLanguageManager(course);
+ if (languageManager == null) {
+ LOG.info("Language manager is null for " + course.getLanguageById().getDisplayName());
+ return;
+ }
+ final File testsFile = new File(taskDirectory, languageManager.getTestFileName());
FileUtil.createIfDoesntExist(testsFile);
try {
FileUtil.writeToFile(testsFile, task.getTestsText());
if (!resourceDirectory.exists()) {
return;
}
+ StudyLanguageManager manager = StudyUtils.getLanguageManager(myCourse);
+ if (manager == null) {
+ LOG.info("Study Language Manager is null for " + myCourse.getLanguageById().getDisplayName());
+ return;
+ }
final File[] files = resourceDirectory.listFiles();
if (files == null) return;
for (File file : files) {
- if (file.getName().equals(StudyNames.TEST_HELPER)) {
- copyFile(file, new File(myProject.getBasePath(), StudyNames.TEST_HELPER));
+ String testHelper = manager.getTestHelperFileName();
+ if (file.getName().equals(testHelper)) {
+ copyFile(file, new File(myProject.getBasePath(), testHelper));
}
if (file.getName().startsWith(StudyNames.LESSON)) {
final File[] tasks = file.listFiles();
if (tasks == null) continue;
for (File task : tasks) {
final File taskDescr = new File(task, StudyNames.TASK_HTML);
- final File taskTests = new File(task, StudyNames.TASK_TESTS);
+ String testFileName = manager.getTestFileName();
+ final File taskTests = new File(task, testFileName);
copyFile(taskDescr, new File(new File(new File(myProject.getBasePath(), file.getName()), task.getName()), StudyNames.TASK_HTML));
- copyFile(taskTests, new File(new File(new File(myProject.getBasePath(), file.getName()), task.getName()), StudyNames.TASK_TESTS));
+ copyFile(taskTests, new File(new File(new File(myProject.getBasePath(), file.getName()), task.getName()),
+ testFileName));
}
}
}
@Nullable
public static Sdk findSdk(@NotNull final Task task, @NotNull final Project project) {
- final Language language = task.getLesson().getCourse().getLanguage();
+ final Language language = task.getLesson().getCourse().getLanguageById();
return StudyExecutor.INSTANCE.forLanguage(language).findSdk(project);
}
@NotNull
public static StudyTestRunner getTestRunner(@NotNull final Task task, @NotNull final VirtualFile taskDir) {
- final Language language = task.getLesson().getCourse().getLanguage();
+ final Language language = task.getLesson().getCourse().getLanguageById();
return StudyExecutor.INSTANCE.forLanguage(language).getTestRunner(task, taskDir);
}
public static RunContentExecutor getExecutor(@NotNull final Project project, @NotNull final Task currentTask,
@NotNull final ProcessHandler handler) {
- final Language language = currentTask.getLesson().getCourse().getLanguage();
+ final Language language = currentTask.getLesson().getCourse().getLanguageById();
return StudyExecutor.INSTANCE.forLanguage(language).getExecutor(project, handler);
}
@NotNull final String filePath,
@NotNull final String sdkPath,
@NotNull final Task currentTask) {
- final Language language = currentTask.getLesson().getCourse().getLanguage();
+ final Language language = currentTask.getLesson().getCourse().getLanguageById();
StudyExecutor.INSTANCE.forLanguage(language).setCommandLineParameters(cmd, project, filePath, sdkPath, currentTask);
}
}
public static void showNoSdkNotification(@NotNull final Task currentTask, @NotNull final Project project) {
- final Language language = currentTask.getLesson().getCourse().getLanguage();
+ final Language language = currentTask.getLesson().getCourse().getLanguageById();
StudyExecutor.INSTANCE.forLanguage(language).showNoSdkNotification(project);
}
balloon.showInCenterOf(checkButton);
Disposer.register(project, balloon);
}
+
+ /**
+ * returns language manager which contains all the information about language specific file names
+ */
+ @Nullable
+ public static StudyLanguageManager getLanguageManager(@NotNull final Course course) {
+ Language language = course.getLanguageById();
+ return language == null ? null : StudyLanguageManager.INSTANCE.forLanguage(language);
+ }
}
public class StudyCheckAction extends DumbAwareAction {
private static final Logger LOG = Logger.getInstance(StudyCheckAction.class.getName());
- private static final String ANSWERS_POSTFIX = "_answers.py";
+ private static final String ANSWERS_POSTFIX = "_answers";
public static final String ACTION_ID = "CheckAction";
public static final String SHORTCUT = "ctrl alt pressed ENTER";
VirtualFile copy = null;
try {
- copy = file.copy(this, taskDir, file.getNameWithoutExtension() + ANSWERS_POSTFIX);
+ copy = file.copy(this, taskDir, file.getNameWithoutExtension() + ANSWERS_POSTFIX + "." + file.getExtension());
final FileDocumentManager documentManager = FileDocumentManager.getInstance();
final Document document = documentManager.getDocument(copy);
if (document != null) {
import com.jetbrains.edu.learning.StudyUtils;
import org.jetbrains.annotations.NotNull;
-import java.awt.*;
import java.awt.*;
import java.io.File;
import java.io.IOException;
*/
public class AnswerPlaceholder implements Comparable, Stateful {
- private static final String WINDOW_POSTFIX = "_window.py";
+ private static final String WINDOW_POSTFIX = "_window";
private static final Logger LOG = Logger.getInstance(AnswerPlaceholder.class);
private int line = 0;
private int start = 0;
g.setColor(color);
Point point = editor.logicalPositionToXY(editor.offsetToLogicalPosition(highlighter.getStartOffset()));
Point pointEnd = editor.logicalPositionToXY(editor.offsetToLogicalPosition(highlighter.getEndOffset()));
- g.drawRect(point.x, point.y - 2, (pointEnd.x - point.x), editor.getLineHeight() + 1);
+ g.drawRect(point.x, point.y, (pointEnd.x - point.x), editor.getLineHeight() + 1);
}
});
editor.getCaretModel().moveToOffset(startOffset);
try {
final VirtualFile windowCopy =
- answerFile.copy(this, answerFile.getParent(), answerFile.getNameWithoutExtension() + myIndex + WINDOW_POSTFIX);
+ answerFile.copy(this, answerFile.getParent(), answerFile.getNameWithoutExtension() + myIndex + WINDOW_POSTFIX + "." + answerFile.getExtension());
final FileDocumentManager documentManager = FileDocumentManager.getInstance();
final Document windowDocument = documentManager.getDocument(windowCopy);
if (windowDocument != null) {
myUpToDate = upToDate;
}
- public Language getLanguage() {
+ public Language getLanguageById() {
return Language.findLanguageByID(myLanguage);
}
+ public String getLanguage() {
+ return myLanguage;
+ }
public void setLanguage(@NotNull final String language) {
myLanguage = language;
}
*/
public class Task implements Stateful {
public static final String TASK_DIR = "task";
- private static final String ourTestFile = "tests.py";
private String name;
private String text;
private String testsText;
return userTests;
}
- public String getTestFile() {
- return ourTestFile;
- }
-
public String getText() {
return text;
}