@erclx/canon 4.114.0 → 4.115.0

package/src/teach/nav.ts

@@ -1,12 +1,13 @@
 import { existsSync, readFileSync } from 'node:fs'
-import { readFile, writeFile } from 'node:fs/promises'
-import { join, relative } from 'node:path'
+import { readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { join, posix, relative } from 'node:path'
 import {
   TEACH_SIDEBAR_BREAKPOINT,
   TEACH_STYLESHEET_COMPONENTS,
 } from '@/design/components'
 import { buildDesignCss } from '@/design/css'
 import { FAVICON_COLORS, faviconLink, renderFavicon } from '@/design/favicon'
+import { stripFrontmatter } from '@/frontmatter'
 import { parseFrontmatter, readField } from '@/indexes/frontmatter'
 import { PROJECT_ROOT } from '@/project-root'
 import { TEACH_FONT_FACES } from '@/teach/fonts'
@@ -14,6 +15,7 @@ import {
   listWorkspaces,
   readWorkspace,
   TEACH_ASSETS,
+  TEACH_GLOSSARY,
   TEACH_LESSONS,
   TEACH_MISSION,
   TEACH_REFERENCE,
@@ -695,6 +697,8 @@ function pageHead(
   title: string,
   cssHref: string | undefined,
   embeddedCss: string | undefined,
+  page: 'index' | 'lesson' = 'index',
+  extraHead = '',
 ): string {
   const style =
     embeddedCss === undefined
@@ -706,10 +710,10 @@ function pageHead(
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>${escapeHtml(title)}</title>
+${extraHead}<title>${escapeHtml(title)}</title>
 ${teachFavicon()}
 ${style}
-${headScript('index')}
+${headScript(page)}
 </head>
 `
 }
@@ -1015,13 +1019,15 @@ async function readLessonMetas(
  * on disk: the mission, the lessons already written, the reference pages, and
  * the glossary. A workspace with no `index.html` yet gets one the same way a
  * workspace that already had one gets its rewrite, since both read the same
- * sources.
+ * sources. A reference row links the rendered sibling, or the markdown itself
+ * on a Bun that cannot render one, so no row points at a file never written.
  */
 async function renderContentsPage(
   root: string,
   workspaces: readonly WorkspaceSummary[],
   detail: WorkspaceDetail,
   metas: readonly LessonMeta[],
+  canRenderMarkdown: boolean,
 ): Promise<string> {
   const missionPath = join(root, detail.path, TEACH_MISSION)
   const description = existsSync(missionPath)
@@ -1076,9 +1082,10 @@ async function renderContentsPage(
       detail.referenceFiles.map(async (file, index) => {
         const title = await readTitle(
           join(root, detail.path, TEACH_REFERENCE, file),
-          basenameTitle(file),
+          referenceFallbackTitle(file),
         )
-        return `<li><a href="${TEACH_REFERENCE}/${file}"><span class="num">R${index + 1}</span><b>${escapeHtml(title)}</b></a></li>`
+        const target = canRenderMarkdown ? renderedReferenceName(file) : file
+        return `<li><a href="${TEACH_REFERENCE}/${target}"><span class="num">R${index + 1}</span><b>${escapeHtml(title)}</b></a></li>`
       }),
     )
   ).join('')
@@ -1117,6 +1124,157 @@ ${renderScripts(false, true)}
 `
 }
 
+/**
+ * Marks a reference page as nav's own output, which is the one test nav applies
+ * before deleting a page whose markdown source is gone. A hand-written HTML
+ * file beside the reference pages carries none and is never touched.
+ */
+const REFERENCE_GENERATOR = '<meta name="generator" content="canon teach nav">'
+
+/** A formatter closes the tag as `/>`, which still marks the page as generated. */
+const REFERENCE_GENERATOR_PATTERN =
+  /<meta name="generator" content="canon teach nav"\s*\/?>/
+
+function renderedReferenceName(file: string): string {
+  return file.replace(/\.md$/, '.html')
+}
+
+function referenceFallbackTitle(file: string): string {
+  return titleCase(file.replace(/\.md$/, ''))
+}
+
+/**
+ * A relative href landing on another reference page's markdown is retargeted
+ * to its rendered sibling, and one landing on the workspace glossary goes to
+ * the glossary the contents page renders under `#gloss`, dropping any fragment
+ * since the entries there carry no per-term anchor. The resources page has no
+ * rendered form, so a blanket suffix swap would break a link to it.
+ */
+function retargetReferenceLinks(
+  html: string,
+  referenceFiles: ReadonlySet<string>,
+): string {
+  return html.replace(
+    /href="([^"#?:]+)\.md([#?][^"]*)?"/g,
+    (match, stem: string, suffix: string | undefined) => {
+      const target = posix.normalize(posix.join(TEACH_REFERENCE, `${stem}.md`))
+      if (target === TEACH_GLOSSARY) return 'href="../index.html#gloss"'
+
+      const [folder, file, ...rest] = target.split('/')
+      if (folder !== TEACH_REFERENCE || rest.length > 0) return match
+      if (!referenceFiles.has(file)) return match
+      return `href="${stem}.html${suffix ?? ''}"`
+    },
+  )
+}
+
+/**
+ * One reference page as a styled page carrying the workspace chrome. The
+ * markdown beside it stays the durable, promotable half, and this file is
+ * regenerated from it on every run. Raw HTML in the markdown is escaped rather
+ * than passed through, since a reference page is plain markdown by contract.
+ */
+async function renderReferencePage(
+  root: string,
+  workspaces: readonly WorkspaceSummary[],
+  detail: WorkspaceDetail,
+  metas: readonly LessonMeta[],
+  file: string,
+): Promise<string> {
+  const source = await readFile(
+    join(root, detail.path, TEACH_REFERENCE, file),
+    'utf8',
+  )
+  const title =
+    readField(parseFrontmatter(source), 'title') ?? referenceFallbackTitle(file)
+
+  const rendered = retargetReferenceLinks(
+    Bun.markdown.html(stripFrontmatter(source), {
+      noHtmlBlocks: true,
+      noHtmlSpans: true,
+    }),
+    new Set(detail.referenceFiles),
+  )
+  const body = /<h1[\s>]/.test(rendered)
+    ? rendered
+    : `<h1>${escapeHtml(title)}</h1>\n${rendered}`
+
+  const teachPrefix = '../../'
+  const workspacePrefix = '../'
+
+  const header = renderHeader(
+    [
+      {
+        label: 'Workspaces',
+        href: `${teachPrefix}index.html`,
+        jump: {
+          ariaLabel: 'Switch workspace',
+          entries: workspaceJumpEntries(workspaces, teachPrefix, detail.slug),
+        },
+      },
+      {
+        label: workspaceLabel(detail),
+        href: `${workspacePrefix}index.html`,
+        jump: {
+          ariaLabel: 'Jump to a lesson',
+          entries: lessonJumpEntries(metas, workspacePrefix, undefined),
+        },
+      },
+      { label: title },
+    ],
+    {
+      heading: workspaceLabel(detail),
+      switcher: workspaceJumpEntries(workspaces, teachPrefix, detail.slug),
+      meta: `${metas.length} lesson${metas.length === 1 ? '' : 's'}`,
+      items: metas.map((meta, index) => ({
+        ordinal: String(index + 1).padStart(2, '0'),
+        label: meta.title,
+        href: `${workspacePrefix}${TEACH_LESSONS}/${meta.file}`,
+        at: false,
+      })),
+      foot: workspaceFoot(detail),
+    },
+  )
+
+  // The sidebar opens as on a lesson, since this page lists no lessons itself.
+  return `${pageHead(title, `${workspacePrefix}${TEACH_ASSETS}/${TEACH_STYLESHEET}`, undefined, 'lesson', `${REFERENCE_GENERATOR}\n`)}<body>
+${header}
+<main class="ref">
+${body.trim()}
+</main>
+${PANE_CLOSE}
+${renderScripts(false, false)}
+</body>
+</html>
+`
+}
+
+/**
+ * Deletes a generated reference page whose markdown source is gone, so a
+ * renamed or removed page leaves nothing no contents row reaches.
+ */
+async function removeOrphanReferencePages(
+  root: string,
+  detail: WorkspaceDetail,
+): Promise<void> {
+  const dir = join(root, detail.path, TEACH_REFERENCE)
+  if (!existsSync(dir)) return
+
+  const sources = new Set(detail.referenceFiles.map(renderedReferenceName))
+  const orphans = (await readdir(dir)).filter(
+    (file) => file.endsWith('.html') && !sources.has(file),
+  )
+
+  await Promise.all(
+    orphans.map(async (file) => {
+      const path = join(dir, file)
+      if (REFERENCE_GENERATOR_PATTERN.test(await readFile(path, 'utf8'))) {
+        await rm(path)
+      }
+    }),
+  )
+}
+
 const REGIONS = ['style', 'header', 'footnav', 'scripts'] as const
 type Region = (typeof REGIONS)[number]
 
@@ -1296,10 +1454,22 @@ export interface NavGenerated {
   readonly root: string
   readonly contents: readonly string[]
   readonly lessons: number
-  /** A lesson file missing a chrome marker, refused rather than rewritten. */
+  /** Reference pages rendered to their `.html` sibling. */
+  readonly reference: number
+  /**
+   * A lesson file missing a chrome marker, refused rather than rewritten, or a
+   * reference page left unrendered on a Bun carrying no markdown renderer.
+   */
   readonly skipped: readonly LessonSkipped[]
 }
 
+const MARKDOWN_RENDERER = 'Bun.markdown'
+
+/** An older Bun carries no `Bun.markdown`, and calling it there throws. */
+function hasMarkdownRenderer(): boolean {
+  return typeof Bun.markdown?.html === 'function'
+}
+
 export type NavOutcome = NavGenerated | TeachRefused
 
 /**
@@ -1343,6 +1513,8 @@ export async function generateNav(
   const contents: string[] = []
   const skipped: LessonSkipped[] = []
   let lessons = 0
+  let reference = 0
+  const canRenderMarkdown = hasMarkdownRenderer()
 
   for (const slug of targetSlugs) {
     const found = await readWorkspace(root, slug)
@@ -1357,10 +1529,31 @@ export async function generateNav(
     const contentsPath = join(root, detail.path, 'index.html')
     await writeFile(
       contentsPath,
-      await renderContentsPage(root, listed.workspaces, detail, metas),
+      await renderContentsPage(
+        root,
+        listed.workspaces,
+        detail,
+        metas,
+        canRenderMarkdown,
+      ),
     )
     contents.push(relative(root, contentsPath))
 
+    for (const file of detail.referenceFiles) {
+      const source = join(detail.path, TEACH_REFERENCE, file)
+      if (!canRenderMarkdown) {
+        skipped.push({ file: source, missing: MARKDOWN_RENDERER })
+        continue
+      }
+
+      await writeFile(
+        join(root, detail.path, TEACH_REFERENCE, renderedReferenceName(file)),
+        await renderReferencePage(root, listed.workspaces, detail, metas, file),
+      )
+      reference += 1
+    }
+    await removeOrphanReferencePages(root, detail)
+
     const css = stripImports(await readFile(cssPath, 'utf8'))
 
     for (let index = 0; index < metas.length; index += 1) {
@@ -1389,6 +1582,7 @@ export async function generateNav(
     root: relative(root, rootPath),
     contents,
     lessons,
+    reference,
     skipped,
   }
 }

package/standards/teach.md

@@ -44,18 +44,19 @@ A workspace failing these is non-conforming even when it satisfies every shape r
 
 ## Layout
 
-| Path                  | Holds                                                  | Required |
-| --------------------- | ------------------------------------------------------ | -------- |
-| `MISSION.md`          | The subject, the learner's starting point, and success | Always   |
-| `RESOURCES.md`        | Sources read and sources found but not opened          | Always   |
-| `GLOSSARY.md`         | Terms the subject defines, one entry each              | Always   |
-| `NOTES.md`            | Session scratch that belongs to no other file          | Optional |
-| `reference/<slug>.md` | Durable reference pages, the promotable half           | Optional |
-| `learning-records/`   | Numbered records of what the learner was taken through | Optional |
-| `lessons/`            | Numbered lessons, generated and disposable             | Optional |
-| `assets/`             | Files several lessons share, including the stylesheet  | Optional |
-
-Only the markdown half answers to a conformance check: `MISSION.md`, `RESOURCES.md`, `GLOSSARY.md`, `NOTES.md`, `reference/`, and `learning-records/`. A lesson is generated markup that nothing downstream cites, so this standard fixes its filename and its location and says nothing about what it contains.
+| Path                    | Holds                                                                   | Required |
+| ----------------------- | ----------------------------------------------------------------------- | -------- |
+| `MISSION.md`            | The subject, the learner's starting point, and success                  | Always   |
+| `RESOURCES.md`          | Sources read and sources found but not opened                           | Always   |
+| `GLOSSARY.md`           | Terms the subject defines, one entry each                               | Always   |
+| `NOTES.md`              | Session scratch that belongs to no other file                           | Optional |
+| `reference/<slug>.md`   | Durable reference pages, the promotable half                            | Optional |
+| `reference/<slug>.html` | Each reference page rendered by `canon teach nav`, never edited by hand | Optional |
+| `learning-records/`     | Numbered records of what the learner was taken through                  | Optional |
+| `lessons/`              | Numbered lessons, generated and disposable                              | Optional |
+| `assets/`               | Files several lessons share, including the stylesheet                   | Optional |
+
+Only the markdown half answers to a conformance check: `MISSION.md`, `RESOURCES.md`, `GLOSSARY.md`, `NOTES.md`, the markdown under `reference/`, and `learning-records/`. A lesson is generated markup that nothing downstream cites, so this standard fixes its filename and its location and says nothing about what it contains. A rendered reference page is the same kind of output, rewritten from its markdown on every `nav` run.
 
 ## Frontmatter
 

package/tooling/go/configs/.golangci.yml

@@ -0,0 +1,25 @@
+version: '2'
+
+linters:
+  default: standard
+  enable:
+    - bodyclose
+    - errorlint
+    - gosec
+    - misspell
+    - noctx
+    - revive
+    - sqlclosecheck
+    - rowserrcheck
+    - unconvert
+  exclusions:
+    paths:
+      - node_modules
+
+formatters:
+  enable:
+    - gofmt
+    - goimports
+  exclusions:
+    paths:
+      - node_modules

package/tooling/go/configs/scripts/verify.sh

@@ -0,0 +1,95 @@
+#!/bin/bash
+set -e
+set -o pipefail
+
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+WHITE='\033[1;37m'
+GREY='\033[0;90m'
+NC='\033[0m'
+
+NESTED="${VERIFY_NESTED:-false}"
+
+log_info() { echo -e "${GREY}│${NC} ${GREEN}✓${NC} $1"; }
+log_error() {
+  echo -e "${GREY}│${NC} ${RED}✗${NC} $1"
+  exit 1
+}
+log_step() { echo -e "${GREY}│${NC}\n${GREY}├${NC} ${WHITE}$1${NC}"; }
+log_skip() { echo -e "${GREY}│ - $1${NC}"; }
+
+pipe_output() { while IFS= read -r line; do echo -e "${GREY}│${NC}  $line"; done; }
+
+check_dependencies() {
+  command -v bun >/dev/null 2>&1 || log_error "bun is not installed"
+  command -v go >/dev/null 2>&1 || log_error "go is not installed"
+  command -v golangci-lint >/dev/null 2>&1 || log_error "golangci-lint is not installed. Run 'go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest'"
+}
+
+check_package() {
+  [ -f package.json ] || log_error "No package.json here. Run 'bun init', then sync the stack again"
+}
+
+has_script() {
+  bun -e 'process.exit(require(process.cwd() + "/package.json").scripts?.[process.argv[1]] ? 0 : 1)' "$1"
+}
+
+# A subfolder synced with --skip base declares none of base's scripts, since
+# the repository root owns them. Each base phase runs only where its script is
+# declared, so this script passes on its own in that subfolder.
+run_base_phase() {
+  local title=$1
+  local script=$2
+  local err_msg=$3
+  local pass_msg=$4
+
+  log_step "$title"
+  if ! has_script "$script"; then
+    log_skip "Skipped: $script is not declared here, so the repository root runs it"
+    return
+  fi
+  run_check "bun run $script" "$err_msg"
+  log_info "$pass_msg"
+}
+
+run_check() {
+  local cmd=$1
+  local err_msg=$2
+  local output
+  if ! output=$(eval "$cmd" 2>&1); then
+    echo "$output" | pipe_output
+    log_error "$err_msg"
+  fi
+  echo "$output" | pipe_output
+}
+
+main() {
+  check_dependencies
+  check_package
+
+  if [ "$NESTED" = false ]; then echo -e "${GREY}┌${NC}"; fi
+
+  echo -e "${GREY}├${NC} ${WHITE}Typecheck${NC}"
+  run_check "bun run typecheck" "Typecheck failed"
+  log_info "Typecheck passed"
+
+  log_step "Lint"
+  run_check "bun run lint" "Lint failed"
+  log_info "Lint passed"
+
+  run_base_phase "Formatting" "format" "Format failed" "Format applied"
+  run_base_phase "Format check" "check:format" "Format check failed" "Format check passed"
+  run_base_phase "Spelling" "check:spell" "Spell check failed" "Spell check passed"
+  run_base_phase "Shell" "check:shell" "Shell check failed" "Shell check passed"
+
+  log_step "Unit tests"
+  run_check "bun run test:run" "Unit tests failed"
+  log_info "Unit tests passed"
+
+  if [ "$NESTED" = false ]; then
+    echo -e "${GREY}└${NC}\n"
+    echo -e "${GREEN}✓ Verification passed${NC}"
+  fi
+}
+
+main "$@"

package/tooling/go/manifest.toml

@@ -0,0 +1,13 @@
+[stack]
+name = "go"
+extends = "base"
+runtime = "go"
+scaffold = "mkdir {{name}} && cd {{name}} && go mod init example.com/{{name}} && go mod edit -ignore=./node_modules"
+
+[scripts]
+"lint" = "golangci-lint run ./..."
+"lint:fix" = "golangci-lint fmt ./... && golangci-lint run --fix ./..."
+"typecheck" = "go vet ./..."
+"test" = "go test ./..."
+"test:run" = "go test -v ./..."
+"build" = "go build ./..."

package/tooling/go/reference.md

@@ -0,0 +1,60 @@
+# Tooling Go reference
+
+> Extends: `base`. Apply base stack first.
+
+## Overview
+
+The go stack covers Go modules linted and formatted by `golangci-lint` v2, type-checked by `go vet`, and tested by `go test`. It ships a golden `.golangci.yml`, a Go-aware `verify.sh`, and a copy-once smoke test.
+
+## Scaffold checklist
+
+1. Scaffold with `go mod init <module-path>`. The module path is the project's own identity, so this stack never ships a `go.mod`.
+2. Keep `./...` out of `node_modules`: `go mod edit -ignore=./node_modules`. At a root sync the base layer installs `node_modules/` inside the module, and a package there can ship a `.go` file that `go vet`, `go test`, and `golangci-lint` would otherwise walk. The directive needs Go 1.25 or later.
+3. Seed `package.json` so the base layer's bun-side tools (husky, prettier, cspell, commitlint) have a target to install into: `bun init -y`.
+4. Install base tooling: `canon tooling sync base . --write`
+5. Install go tooling: `canon tooling sync go . --write`
+6. Install the linter: `go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest`. The manifest declares no `[dependencies.dev]`, because manifest injection runs `bun add -D`, which cannot install a Go tool. This step stays manual.
+7. Run `bun run lint:fix` then `bun run check`.
+
+The go stack also ships `smoke_test.go` at the module root as a copy-once seed. A module with no `.go` file fails `golangci-lint run`, `go vet`, and `go test` on an empty package list, so the seed is what lets `bun run check` pass on a fresh scaffold. It declares `package main`, so delete or rename it once the root package takes another name, or the build reports two packages in one folder.
+
+## golangci-lint
+
+- Use config `version: '2'`.
+- Start from `default: standard`.
+- Enable `bodyclose`, `errorlint`, `gosec`, `misspell`, `noctx`, `revive`, `sqlclosecheck`, `rowserrcheck`, and `unconvert`. The two SQL linters report only on `database/sql` call sites, so they cost nothing in a module without a database.
+- Enable formatters `gofmt` and `goimports`. `lint:fix` runs `golangci-lint fmt` ahead of `golangci-lint run --fix`.
+- Exclude `node_modules` from both linters and formatters. The `go.mod` `ignore` directive in the checklist covers every Go tool, but `go.mod` belongs to the project and sync cannot write it, so the config keeps `golangci-lint run` from reporting and `golangci-lint fmt` from rewriting a vendored `.go` file in a module that never added the directive.
+
+## verify.sh
+
+- Run Typecheck (`go vet`), Lint (`golangci-lint run`), and Unit tests (`go test -v`), plus the four base phases wherever the folder declares their scripts.
+- Keep `build` out of `verify.sh`. `go build ./...` exits 1 with `no packages to build` on a module holding only a test file, and a seeded `main.go` would assume every module is a binary rather than a library.
+- Keep `-race` out of `test:run`. The race detector needs cgo and a C toolchain, so it belongs in CI rather than in a local `bun run check`.
+
+## CI
+
+- Install Go with `actions/setup-go`, reading the version from `go.mod` through `go-version-file`.
+- Install the linter with the same `go install` line as the scaffold checklist.
+- Run `go test -race ./...` in CI.
+
+## Anti-patterns
+
+- Do not ship `go.mod` or `go.sum` from tooling. Both belong to the project, and a golden copy would overwrite its module path on every sync.
+- Do not pin the linter through a `tools.go` file or a `tool` directive in `go.mod`. The module is project-owned, so the install stays in the checklist.
+- Do not ship a `Dockerfile`, `.dockerignore`, or `compose.yaml` under tooling. Those are deployment choices and belong in the project itself.
+
+## Development docs (extend)
+
+Append to the `## Scripts` table:
+
+| `bun run lint` | Run `golangci-lint run`. |
+| `bun run lint:fix` | Format with `golangci-lint fmt`, then auto-fix with `golangci-lint run --fix`. |
+| `bun run typecheck` | Run `go vet`. |
+| `bun run test` | Run `go test`. |
+| `bun run test:run` | Run `go test -v` (used by `verify`). |
+| `bun run build` | Run `go build`. |
+
+## CI docs (extend)
+
+In `canon/context/ci.md`, the Typecheck row's assertion reads: `` `go vet ./...` passes ``. Add a Lint row whose assertion reads: `` `golangci-lint run` passes ``. Add a Tests row whose assertion reads: `` `go test -race ./...` exits 0 ``.

package/tooling/go/seeds/.cspell/tech-stack.txt

@@ -0,0 +1,16 @@
+bodyclose
+Errorf
+errorlint
+Fatalf
+gofmt
+goimports
+golangci
+goroutine
+goroutines
+gosec
+httptest
+noctx
+nolint
+rowserrcheck
+sqlclosecheck
+unconvert

package/tooling/go/seeds/smoke_test.go

@@ -0,0 +1,9 @@
+package main
+
+import "testing"
+
+func TestSmoke(t *testing.T) {
+	if 1+1 != 2 {
+		t.Fatal("arithmetic is broken")
+	}
+}

package/tooling/php/configs/.php-cs-fixer.dist.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+$finder = (new PhpCsFixer\Finder())
+    ->in([__DIR__ . '/src', __DIR__ . '/tests']);
+
+return (new PhpCsFixer\Config())
+    ->setRiskyAllowed(true)
+    ->setRules([
+        '@PER-CS' => true,
+        'declare_strict_types' => true,
+        'strict_comparison' => true,
+        'no_unused_imports' => true,
+        'ordered_imports' => true,
+    ])
+    ->setFinder($finder)
+    ->setCacheFile(__DIR__ . '/.php-cs-fixer.cache');

package/tooling/php/configs/phpstan.neon

@@ -0,0 +1,5 @@
+parameters:
+    level: max
+    paths:
+        - src
+        - tests

package/tooling/php/configs/phpunit.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+         failOnWarning="true"
+         failOnRisky="true">
+    <testsuites>
+        <testsuite name="unit">
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    <source>
+        <include>
+            <directory>src</directory>
+        </include>
+    </source>
+</phpunit>