programming-challenges/cli/services/Template.ts

import path from "node:path"
import { fileURLToPath } from "node:url"
import fs from "node:fs"

import replaceInFileDefault from "replace-in-file"
import date from "date-and-time"

import { copyDirectory } from "../utils/copyDirectory.js"

const { replaceInFile } = replaceInFileDefault

const TEMPLATE_PATH = fileURLToPath(new URL("../../templates", import.meta.url))
const TEMPLATE_DOCKER_PATH = path.join(TEMPLATE_PATH, "docker")
const TEMPLATE_CHALLENGE_PATH = path.join(TEMPLATE_PATH, "challenge")
const TEMPLATE_SOLUTION_PATH = path.join(TEMPLATE_PATH, "solution")
const TEMPLATE_SOLUTION_BASE_PATH = path.join(TEMPLATE_SOLUTION_PATH, "base")

export interface TemplateDockerOptions {
  programmingLanguage: string
  destination: string
}

export interface TemplateChallengeOptions {
  name: string
  githubUser?: string
  destination: string
}

export interface TemplateSolutionOptions {
  challengeName: string
  programmingLanguageName: string
  name: string
  githubUser?: string
  destination: string
}

export interface ReplaceInDestinationOptions {
  destination: string
  name: string
  description: string
}

class Template {
  private getDescription(githubUser?: string): string {
    const dateString = date.format(new Date(), "D MMMM Y", true)
    let description = "Created"
    if (githubUser != null) {
      description += ` by [@${githubUser}](https://github.com/${githubUser})`
    }
    description += ` on ${dateString}.`
    return description
  }

  private async replaceInDestination(
    options: ReplaceInDestinationOptions,
  ): Promise<void> {
    const { name, description, destination } = options
    const readmePath = path.join(destination, "README.md")
    await replaceInFile({
      files: [readmePath],
      from: /{{ name }}/g,
      to: name,
    })
    await replaceInFile({
      files: [readmePath],
      from: /{{ description }}/g,
      to: description,
    })
  }

  public async docker(options: TemplateDockerOptions): Promise<void> {
    const { programmingLanguage, destination } = options
    const sourcePath = path.join(TEMPLATE_DOCKER_PATH, programmingLanguage)
    await copyDirectory(sourcePath, destination)
  }

  public async solution(options: TemplateSolutionOptions): Promise<void> {
    const {
      destination,
      githubUser,
      name,
      challengeName,
      programmingLanguageName,
    } = options
    const templateLanguagePath = path.join(
      TEMPLATE_SOLUTION_PATH,
      programmingLanguageName,
    )
    await this.verifySupportedProgrammingLanguage(programmingLanguageName)
    await fs.promises.mkdir(destination, { recursive: true })
    await copyDirectory(templateLanguagePath, destination)
    await copyDirectory(TEMPLATE_SOLUTION_BASE_PATH, destination)
    await this.replaceInDestination({
      name: `${challengeName}/${programmingLanguageName}/${name}`,
      description: this.getDescription(githubUser),
      destination,
    })
  }

  public async challenge(options: TemplateChallengeOptions): Promise<void> {
    const { destination, githubUser, name } = options
    await copyDirectory(TEMPLATE_CHALLENGE_PATH, destination)
    await this.replaceInDestination({
      name,
      description: this.getDescription(githubUser),
      destination,
    })
  }

  public async getProgrammingLanguages(): Promise<string[]> {
    const languages = await fs.promises.readdir(TEMPLATE_SOLUTION_PATH)
    return languages.filter((language) => {
      return language !== "base"
    })
  }

  public async verifySupportedProgrammingLanguage(
    language: string,
  ): Promise<void> {
    const languages = await this.getProgrammingLanguages()
    if (!languages.includes(language)) {
      throw new Error("This programming language is not supported yet.")
    }
  }
}

export const template = new Template()