course-format-ts 1.0.0

package/src/courseFormat/AnswerPlaceholder.ts

@@ -0,0 +1,121 @@
+import { CheckStatus } from "./CheckStatus"
+import { TaskFile } from "./TaskFile"
+import { AnswerPlaceholderDependency } from "./AnswerPlaceholderDependency"
+
+export class AnswerPlaceholder {
+  offset = -1
+  length = -1
+  index = -1
+
+  private _initialState?: MyInitialState
+  private _taskFile?: TaskFile
+
+  placeholderDependency?: AnswerPlaceholderDependency
+  isInitializedFromDependency = false
+  possibleAnswer = ""
+  placeholderText = ""
+  selected = false
+  status: CheckStatus = CheckStatus.Unchecked
+  isVisible = true
+  studentAnswer?: string
+
+  constructor()
+  constructor(offset: number, placeholderText: string)
+  constructor(offset?: number, placeholderText?: string) {
+    if (offset !== undefined && placeholderText !== undefined) {
+      this.offset = offset
+      this.length = placeholderText.length
+      this.placeholderText = placeholderText
+    }
+  }
+
+  get initialState(): MyInitialState {
+    if (!this._initialState) {
+      throw new Error("No initial state for answer placeholder")
+    }
+    return this._initialState
+  }
+
+  set initialState(value: MyInitialState) {
+    this._initialState = value
+  }
+
+  get taskFile(): TaskFile {
+    if (!this._taskFile) {
+      throw new Error(`Task file is null for answer placeholder`)
+    }
+    return this._taskFile
+  }
+
+  set taskFile(value: TaskFile) {
+    this._taskFile = value
+  }
+
+  init(file: TaskFile, isRestarted: boolean): void {
+    this.taskFile = file
+    if (isRestarted) return
+    if (this.placeholderDependency) {
+      this.placeholderDependency.answerPlaceholder = this
+    }
+    this.initialState = new MyInitialState(this.offset, this.length)
+    this.status = file.task.status
+  }
+
+  reset(revertStartOffset: boolean): void {
+    if (revertStartOffset) {
+      this.offset = this.initialState.offset
+    }
+    this.length = this.initialState.length
+    this.status = CheckStatus.Unchecked
+    this.isInitializedFromDependency = false
+  }
+
+  initEmpty(): void {
+    this.initialState = new MyInitialState(this.offset, this.placeholderText.length)
+  }
+
+  get isCurrentlyVisible(): boolean {
+    let result = this.shouldBeVisible
+    if (this.placeholderDependency) {
+      result = result || !this.isInitializedFromDependency
+    }
+    return result
+  }
+
+  get shouldBeVisible(): boolean {
+    if (!this.placeholderDependency) {
+      return this.isVisible
+    }
+    return this.isVisible && this.placeholderDependency.isVisible
+  }
+
+  isValid(textLength: number): boolean {
+    return this.offset >= 0 && this.length >= 0 && this.endOffset <= textLength
+  }
+
+  get endOffset(): number {
+    return this.offset + this.length
+  }
+
+  toString(): string {
+    const task = this.taskFile.task
+    const lesson = task.lesson
+    const section = lesson.section
+    const sectionPrefix = section ? `${section.name}#` : ""
+    return `${sectionPrefix}${lesson.name}#${task.name}#${this.taskFile.name}[${this.offset}, ${this.endOffset}]`
+  }
+}
+
+export class MyInitialState {
+  length = -1
+  offset = -1
+
+  constructor(initialOffset?: number, initialLength?: number) {
+    if (initialOffset !== undefined) {
+      this.offset = initialOffset
+    }
+    if (initialLength !== undefined) {
+      this.length = initialLength
+    }
+  }
+}

package/src/courseFormat/AnswerPlaceholderComparator.ts

@@ -0,0 +1,7 @@
+import { AnswerPlaceholder } from "./AnswerPlaceholder"
+
+export const AnswerPlaceholderComparator = {
+  compare(a: AnswerPlaceholder, b: AnswerPlaceholder): number {
+    return a.offset - b.offset
+  },
+}

package/src/courseFormat/AnswerPlaceholderDependency.ts

@@ -0,0 +1,122 @@
+import { AnswerPlaceholder } from "./AnswerPlaceholder"
+import { Course } from "./Course"
+import { Lesson } from "./Lesson"
+import { message } from "./uiMessages"
+
+const DEPENDENCY_PATTERN = /(([^#]+)#)?([^#]+)#([^#]+)#([^#]+)#(\d+)/
+
+export class AnswerPlaceholderDependency {
+  sectionName?: string
+  lessonName = ""
+  taskName = ""
+  fileName = ""
+  placeholderIndex = 0
+  isVisible = true
+  answerPlaceholder!: AnswerPlaceholder
+
+  constructor(
+    answerPlaceholder?: AnswerPlaceholder,
+    sectionName?: string | null,
+    lessonName = "",
+    taskName = "",
+    fileName = "",
+    placeholderIndex = 0,
+    isVisible = true
+  ) {
+    if (answerPlaceholder) {
+      this.answerPlaceholder = answerPlaceholder
+    }
+    this.sectionName = sectionName ?? undefined
+    this.lessonName = lessonName
+    this.taskName = taskName
+    this.fileName = fileName
+    this.placeholderIndex = placeholderIndex
+    this.isVisible = isVisible
+  }
+
+  resolve(course: Course): AnswerPlaceholder | undefined {
+    const lesson = course.getLesson(this.sectionName, this.lessonName)
+    const task = lesson?.getTask(this.taskName)
+    const taskFile = task?.getTaskFile(this.fileName)
+    return taskFile?.answerPlaceholders[this.placeholderIndex]
+  }
+
+  toString(): string {
+    const section = this.sectionName ? `${this.sectionName}#` : ""
+    return `${section}${this.lessonName}#${this.taskName}#${this.fileName}#${this.placeholderIndex + 1}`
+  }
+
+  static create(answerPlaceholder: AnswerPlaceholder, text: string): AnswerPlaceholderDependency | null {
+    if (!text.trim()) {
+      return null
+    }
+    const task = answerPlaceholder.taskFile.task
+    const match = text.match(DEPENDENCY_PATTERN)
+    if (!match) {
+      throw new InvalidDependencyException(text)
+    }
+
+    const sectionName = match[2]
+    const lessonName = match[3]
+    const taskName = match[4]
+    const filePath = toSystemIndependent(match[5])
+    const placeholderIndex = Number.parseInt(match[6], 10) - 1
+    if (Number.isNaN(placeholderIndex)) {
+      throw new InvalidDependencyException(text)
+    }
+
+    const dependency = new AnswerPlaceholderDependency(
+      answerPlaceholder,
+      sectionName,
+      lessonName,
+      taskName,
+      filePath,
+      placeholderIndex,
+      true
+    )
+    const targetPlaceholder = dependency.resolve(task.course)
+    if (!targetPlaceholder) {
+      throw new InvalidDependencyException(text, message("exception.placeholder.non.existing"))
+    }
+    if (targetPlaceholder.taskFile.task === task) {
+      throw new InvalidDependencyException(text, message("exception.placeholder.wrong.reference.to.source"))
+    }
+    if (refersToNextTask(task, targetPlaceholder.taskFile.task)) {
+      throw new InvalidDependencyException(text, message("exception.placeholder.wrong.reference.to.next"))
+    }
+    return dependency
+  }
+}
+
+export class InvalidDependencyException extends Error {
+  readonly customMessage: string
+
+  constructor(dependencyText: string, customMessage?: string) {
+    super(
+      customMessage
+        ? `'${dependencyText}' is not a valid placeholder dependency\n${customMessage}`
+        : `'${dependencyText}' is not a valid placeholder dependency`
+    )
+    this.customMessage = customMessage ?? message("exception.placeholder.invalid.dependency")
+  }
+}
+
+function toSystemIndependent(pathValue: string): string {
+  return pathValue.replace(/\\/g, "/")
+}
+
+function refersToNextTask(sourceTask: { lesson: Lesson; index: number }, targetTask: { lesson: Lesson; index: number }): boolean {
+  const sourceLesson = sourceTask.lesson
+  const targetLesson = targetTask.lesson
+  if (sourceLesson === targetLesson) {
+    return targetTask.index > sourceTask.index
+  }
+  if (sourceLesson.section === targetLesson.section) {
+    return targetLesson.index > sourceLesson.index
+  }
+  return getIndexInCourse(targetLesson) > getIndexInCourse(sourceLesson)
+}
+
+function getIndexInCourse(lesson: Lesson): number {
+  return lesson.section?.index ?? lesson.index
+}

package/src/courseFormat/CheckFeedback.ts

@@ -0,0 +1,71 @@
+import { CheckResult, CheckResultDiff } from "./CheckResult"
+import { CheckStatus } from "./CheckStatus"
+import { EduTestInfo } from "./EduTestInfo"
+import { logger } from "./loggerUtils"
+
+export class CheckFeedback {
+  readonly failedTestInfo?: EduTestInfo
+  readonly time?: Date
+  private _message = ""
+  private _expected?: string
+  private _actual?: string
+
+  constructor(
+    failedTestInfo?: EduTestInfo | null,
+    time?: Date | null
+  ) {
+    this.failedTestInfo = failedTestInfo ?? undefined
+    this.time = time ?? undefined
+  }
+
+  static fromMessage(message: string, time?: Date | null, expected?: string | null, actual?: string | null): CheckFeedback {
+    const feedback = new CheckFeedback(undefined, time ?? undefined)
+    feedback.message = message
+    feedback.expected = expected ?? undefined
+    feedback.actual = actual ?? undefined
+    return feedback
+  }
+
+  static fromCheckResult(time: Date, checkResult: CheckResult): CheckFeedback {
+    const feedback = new CheckFeedback(checkResult.executedTestsInfo[0], time)
+    feedback.expected = checkResult.diffResolved?.expected
+    feedback.actual = checkResult.diffResolved?.actual
+    feedback.message = checkResult.messageResolved
+    return feedback
+  }
+
+  get message(): string {
+    return this._message || this.failedTestInfo?.message || ""
+  }
+
+  set message(value: string) {
+    this._message = value
+  }
+
+  get expected(): string | undefined {
+    return this._expected ?? this.failedTestInfo?.checkResultDiff?.expected
+  }
+
+  set expected(value: string | undefined) {
+    this._expected = value
+  }
+
+  get actual(): string | undefined {
+    return this._actual ?? this.failedTestInfo?.checkResultDiff?.actual
+  }
+
+  set actual(value: string | undefined) {
+    this._actual = value
+  }
+
+  toCheckResult(status: CheckStatus): CheckResult {
+    const expected = this.expected
+    const actual = this.actual
+    if ((expected === undefined && actual !== undefined) || (expected !== undefined && actual === undefined)) {
+      logger("CheckFeedback").warn("Expected/Actual: one value is missing. Second value would be ignored")
+    }
+    const diff =
+      expected !== undefined && actual !== undefined ? new CheckResultDiff(expected, actual) : undefined
+    return new CheckResult(status, this.message, undefined, diff)
+  }
+}

package/src/courseFormat/CheckResult.ts

@@ -0,0 +1,92 @@
+import { CheckResultSeverity } from "./CheckResultSeverity"
+import { CheckStatus } from "./CheckStatus"
+import { FAILED_TO_CHECK_URL, LOGIN_NEEDED_MESSAGE, NO_TESTS_URL } from "./EduFormatNames"
+import { message } from "./uiMessages"
+import { EduTestInfo } from "./EduTestInfo"
+
+export class CheckResult {
+  readonly status: CheckStatus
+  readonly severity: CheckResultSeverity
+  readonly hyperlinkAction?: () => void
+  readonly executedTestsInfo: EduTestInfo[]
+
+  private readonly firstFailedTest?: EduTestInfo
+
+  details?: string
+  diff?: CheckResultDiff
+  messageText: string
+
+  constructor(
+    status: CheckStatus,
+    messageText = "",
+    details?: string | null,
+    diff?: CheckResultDiff | null,
+    severity: CheckResultSeverity = CheckResultSeverity.Info,
+    hyperlinkAction?: (() => void) | null,
+    executedTestsInfo: EduTestInfo[] = []
+  ) {
+    this.status = status
+    this.severity = severity
+    this.hyperlinkAction = hyperlinkAction ?? undefined
+    this.executedTestsInfo = executedTestsInfo
+    this.firstFailedTest = this.executedTestsInfo.find((test) => !test.isSuccess)
+    this.details = details ?? undefined
+    this.diff = diff ?? undefined
+    this.messageText = messageText
+  }
+
+  get fullMessage(): string {
+    return this.details ? `${this.messageText}\n\n${this.details}` : this.messageText
+  }
+
+  get isSolved(): boolean {
+    return this.status === CheckStatus.Solved
+  }
+
+  get detailsResolved(): string | undefined {
+    return this.details ?? this.firstFailedTest?.details
+  }
+
+  get diffResolved(): CheckResultDiff | undefined {
+    return this.diff ?? this.firstFailedTest?.checkResultDiff
+  }
+
+  get messageResolved(): string {
+    return this.messageText || this.firstFailedTest?.message || ""
+  }
+
+  static NO_LOCAL_CHECK = new CheckResult(
+    CheckStatus.Unchecked,
+    message("check.result.local.check.unavailable")
+  )
+  static LOGIN_NEEDED = new CheckResult(CheckStatus.Unchecked, LOGIN_NEEDED_MESSAGE)
+  static CONNECTION_FAILED = new CheckResult(
+    CheckStatus.Unchecked,
+    message("check.result.connection.failed")
+  )
+  static SOLVED = new CheckResult(CheckStatus.Solved)
+  static CANCELED = new CheckResult(CheckStatus.Unchecked, message("check.result.canceled"))
+  static UNCHECKED = new CheckResult(CheckStatus.Unchecked)
+
+  static get noTestsRun(): CheckResult {
+    return new CheckResult(
+      CheckStatus.Unchecked,
+      message("check.no.tests.with.help.guide", NO_TESTS_URL)
+    )
+  }
+
+  static get failedToCheck(): CheckResult {
+    return new CheckResult(
+      CheckStatus.Unchecked,
+      message("error.failed.to.launch.checking.with.help.guide", FAILED_TO_CHECK_URL)
+    )
+  }
+}
+
+export class CheckResultDiff {
+  constructor(
+    readonly expected: string,
+    readonly actual: string,
+    readonly title = ""
+  ) {}
+}

package/src/courseFormat/CheckResultSeverity.ts

@@ -0,0 +1,13 @@
+export enum CheckResultSeverity {
+  Info = "Info",
+  Warning = "Warning",
+  Error = "Error",
+}
+
+export function isWarning(severity: CheckResultSeverity): boolean {
+  return severity === CheckResultSeverity.Warning
+}
+
+export function isInfo(severity: CheckResultSeverity): boolean {
+  return severity === CheckResultSeverity.Info
+}

package/src/courseFormat/CheckStatus.ts

@@ -0,0 +1,5 @@
+export enum CheckStatus {
+  Unchecked = "Unchecked",
+  Failed = "Failed",
+  Solved = "Solved",
+}

package/src/courseFormat/Course.ts

@@ -0,0 +1,201 @@
+import { LessonContainer } from "./LessonContainer"
+import { CourseMode } from "./CourseMode"
+import { CourseVisibility } from "./CourseVisibility"
+import { EduFile } from "./EduFile"
+import { PluginInfo } from "./PluginInfo"
+import { UserInfo } from "./UserInfo"
+import { Vendor } from "./Vendor"
+import { LESSON, OBJECTIVE_C, CPP, PYCHARM, DEFAULT_ENVIRONMENT } from "./EduFormatNames"
+import { Lesson } from "./Lesson"
+import { Section } from "./Section"
+import { ItemContainer } from "./ItemContainer"
+import { Language } from "./Language"
+
+export abstract class Course extends LessonContainer {
+  description = ""
+  environment = DEFAULT_ENVIRONMENT
+  environmentSettings: Record<string, string> = {}
+  courseMode: CourseMode = CourseMode.STUDENT
+  solutionsHidden = false
+  disabledFeatures: string[] = []
+  visibility: CourseVisibility = CourseVisibility.LocalVisibility
+  additionalFiles: EduFile[] = []
+  pluginDependencies: PluginInfo[] = []
+  private nonEditableFiles: Set<string> = new Set()
+  authors: UserInfo[] = []
+  isLocal = false
+  needWriteYamlText = false
+  languageCode = "en"
+
+  get type(): string {
+    return this.itemType
+  }
+
+  get title(): string {
+    return this.name
+  }
+
+  set title(value: string) {
+    this.name = value
+  }
+
+  get language(): string {
+    return this.languageCode
+  }
+
+  get content(): Lesson[] {
+    return this.lessons
+  }
+
+  isMarketplace = false
+  vendor?: Vendor
+  marketplaceCourseVersion = 0
+  organization?: string
+  isMarketplacePrivate = false
+  createDate: Date = new Date(0)
+  feedbackLink?: string
+  license?: string
+
+  customContentPath = ""
+
+  private _languageId = ""
+  languageVersion?: string
+  private _programmingLanguage = ""
+
+  get programmingLanguage(): string {
+    return this._programmingLanguage
+  }
+
+  set programmingLanguage(value: string | null) {
+    if (!value) return
+    this._programmingLanguage = value
+    const parts = value.split(" ")
+    this.languageId = parts[0]
+    this.languageVersion = parts[1]
+  }
+
+  get languageId(): string {
+    if (this._languageId === OBJECTIVE_C || this._languageId === CPP) {
+      return Language.findLanguageByName("C/C++") ?? this._languageId
+    }
+    return this._languageId
+  }
+
+  set languageId(value: string) {
+    this._languageId = value
+  }
+
+  initCourse(isRestarted: boolean): void {
+    this.init(this, isRestarted)
+  }
+
+  override init(parentItem: ItemContainer, isRestarted: boolean): void {
+    if (!(parentItem instanceof Course)) {
+      throw new Error("Parent for course must be itself")
+    }
+    super.init(parentItem, isRestarted)
+  }
+
+  getLesson(sectionName?: string, lessonName?: string): Lesson | undefined
+  getLesson(param?: string | number | ((lesson: Lesson) => boolean)): Lesson | undefined
+  getLesson(param1?: string | number | ((lesson: Lesson) => boolean), param2?: string): Lesson | undefined {
+    if (typeof param1 === "string" && param2 !== undefined) {
+      const sectionName = param1
+      const lessonName = param2
+      if (sectionName) {
+        const section = this.getSection(sectionName)
+        if (section) {
+          return section.getLesson(lessonName)
+        }
+      }
+      return this.lessons.find((lesson) => lesson.name === lessonName)
+    }
+    if (param1 === undefined) return undefined
+    if (typeof param1 === "string") {
+      return super.getLesson(param1)
+    }
+    if (typeof param1 === "number") {
+      return super.getLesson(param1)
+    }
+    return super.getLesson(param1 as (lesson: Lesson) => boolean)
+  }
+
+  get sections(): Section[] {
+    return this.items.filter((item): item is Section => item instanceof Section)
+  }
+
+  addSection(section: Section): void {
+    this.addItem(section)
+  }
+
+  removeSection(section: Section): void {
+    this.removeItem(section)
+  }
+
+  getSection(name: string): Section | undefined
+  getSection(predicate: (section: Section) => boolean): Section | undefined
+  getSection(param: string | ((section: Section) => boolean)): Section | undefined {
+    if (typeof param === "string") {
+      return this.sections.find((section) => section.name === param)
+    }
+    return this.sections.find(param)
+  }
+
+  get course(): Course {
+    return this
+  }
+
+  get itemType(): string {
+    return PYCHARM
+  }
+
+  get isStudy(): boolean {
+    return this.courseMode === CourseMode.STUDENT
+  }
+
+  override sortItems(): void {
+    super.sortItems()
+    this.sections.forEach((section) => section.sortItems())
+  }
+
+  toString(): string {
+    return this.name
+  }
+
+  get authorFullNames(): string[] {
+    return this.organization ? [this.organization] : this.authors.map((author) => author.getFullName())
+  }
+
+  get humanLanguage(): string {
+    try {
+      return new Intl.DisplayNames([this.languageCode], { type: "language" }).of(this.languageCode) ?? this.languageCode
+    }
+    catch {
+      return this.languageCode
+    }
+  }
+
+  get isStepikRemote(): boolean {
+    return false
+  }
+
+  incrementMarketplaceCourseVersion(remoteCourseVersion: number): void {
+    this.marketplaceCourseVersion = remoteCourseVersion + 1
+  }
+
+  isEditableFile(path: string): boolean {
+    return !this.nonEditableFiles.has(path)
+  }
+
+  addNonEditableFile(path?: string | null): void {
+    if (path && this.isStudy) {
+      this.nonEditableFiles.add(path)
+    }
+  }
+
+  removeNonEditableFile(path?: string | null): void {
+    if (path && this.isStudy) {
+      this.nonEditableFiles.delete(path)
+    }
+  }
+}

package/src/courseFormat/CourseMode.ts

@@ -0,0 +1,4 @@
+export enum CourseMode {
+  STUDENT = "STUDENT",
+  EDUCATOR = "EDUCATOR",
+}

package/src/courseFormat/CourseVisibility.ts

@@ -0,0 +1,4 @@
+export enum CourseVisibility {
+  LocalVisibility = "LocalVisibility",
+  RemoteVisibility = "RemoteVisibility",
+}

package/src/courseFormat/CourseraCourse.ts

@@ -0,0 +1,10 @@
+import { Course } from "./Course"
+import { COURSERA } from "./EduFormatNames"
+
+export class CourseraCourse extends Course {
+  submitManually = false
+
+  override get itemType(): string {
+    return COURSERA
+  }
+}

package/src/courseFormat/DescriptionFormat.ts

@@ -0,0 +1,5 @@
+export enum DescriptionFormat {
+  HTML = "HTML",
+  MD = "MD",
+  TEXT = "TEXT",
+}