jutty/en
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Compare commits

base: jutty:main
Branches Tags
jutty:main
jutty:ci-testing
jutty:unstable
jutty:v0.4.0-alpha
jutty:latest
jutty:v0.3.1-alpha
jutty:v0.3.0-alpha
jutty:v0.2.0-alpha
jutty:v0.1.0-alpha
..
compare: jutty:unstable
Branches Tags
jutty:main
jutty:ci-testing
jutty:unstable
jutty:v0.4.0-alpha
jutty:latest
jutty:v0.3.1-alpha
jutty:v0.3.0-alpha
jutty:v0.2.0-alpha
jutty:v0.1.0-alpha

No commits in common. "main" and "unstable" have entirely different histories.
main ... unstable

109 changed files with 2185 additions and 8717 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.clippy.toml
View file

@ -2,4 +2,3 @@ allow-unwrap-in-tests = true
allow-expect-in-tests = true
single-char-binding-names-threshold = 2
upper-case-acronyms-aggressive = true
allow-indexing-slicing-in-tests = true

68
.forgejo/workflows/check.yaml Normal file
View file

@ -0,0 +1,68 @@
on:
push:
paths:
- src/**
- tests/**
- .forgejo/**
- Cargo.toml
- Cargo.lock
env:
JUST_VERSION: 1.45.0
JUST_SHA256SUM: dc3f958aaf8c6506dd90426e9b03f86dd15e74a6467ee0e54929f750af3d9e49
CARGO_LLVM_COV_VERSION: 0.6.21
CARGO_LLVM_COV_SHA256SUM: 57f491aedf7cdb261538ceb49cbb1ee9d27df7ca205a5e1a009caaf5cb911afb
jobs:
verify:
runs-on: docker
timeout-minutes: 20
container:
image: rust:slim
steps:
- name: Install action dependencies
run: |
apt-get install --no-install-recommends --update -y nodejs curl
- name: Checkout code
uses: actions/checkout@v6
- name: Setup Rust toolchain
run: |
rustup component add rustfmt clippy llvm-tools-preview
- name: Setup additional tooling
run: |
fetch() {
repo="$1"; tag="$2"; filename="$3"; digest="$4"
curl -sSLO -w '%{stderr}HTTP %{response_code} %{url}\n' \
"https://github.com/$repo/releases/download/$tag/$filename"
printf '%s %s\n' "$digest" "$filename" > digest
sha256sum --check digest && tar xf "$filename" -C tools
}
mkdir tools
fetch casey/just ${{ env.JUST_VERSION }} \
just-${{ env.JUST_VERSION }}-x86_64-unknown-linux-musl.tar.gz \
${{ env.JUST_SHA256SUM }}
fetch taiki-e/cargo-llvm-cov v${{ env.CARGO_LLVM_COV_VERSION }} \
cargo-llvm-cov-x86_64-unknown-linux-gnu.tar.gz \
${{ env.CARGO_LLVM_COV_SHA256SUM }}
mv -v tools/just tools/cargo-llvm-cov /usr/local/bin
- name: Build
run: just build
- name: Format
run: just format-assess
- name: Lint
run: just lint-assess
- name: Cargo check
run: just check
- name: Test
run: just test
- name: Assess test coverage
run: just cover-assess

75
.forgejo/workflows/publish.yaml
View file

@ -1,75 +0,0 @@
on:
push:
tags:
- 'v*'
workflow_dispatch:
inputs:
upload:
description: 'Upload built assets to the git.jutty.dev package registry'
type: boolean
required: false
default: true
jobs:
publish:
runs-on: docker
timeout-minutes: 20
container:
image: rust:slim
steps:
- name: Install action dependencies
run: apt-get install --no-install-recommends --update -y nodejs curl git
- name: Checkout code
uses: actions/checkout@v6
with:
fetch-tags: true
- name: Setup Rust toolchain
run: |
rustup component add llvm-tools-preview
rustup component add --toolchain nightly rustfmt clippy
rustup target add x86_64-unknown-linux-gnu
rustup target add x86_64-unknown-linux-musl
- name: Setup additional tooling
run: .forgejo/workflows/setup-tools.sh
- name: Setup CI user
run: |
useradd -m ci && chown -R ci:ci .
git config --global --add safe.directory "$PWD"
- name: Run all assessments
run: just ci verify
- name: Build x64 glibc release binary
run: just release-build x86_64-unknown-linux-gnu
- name: Build x64 musl release binary
run: just release-build x86_64-unknown-linux-musl
- name: Calculate SHA-256 hashes
run: just shasum
- name: Publish x64 glibc binary to git.jutty.dev registry
if: ${{ inputs.upload }}
run: |
version=$(./target/x86_64-unknown-linux-gnu/release/en --version)
api_root=https://git.jutty.dev/api
url=$api_root/packages/jutty/generic/en/$version/en-x64-linux-gnu
curl -fsSL \
--user jutty:${{ secrets.GJD_REGISTRY_TOKEN }} \
--upload-file target/x86_64-unknown-linux-gnu/release/en $url
- name: Publish x64 musl binary to git.jutty.dev registry
if: ${{ inputs.upload }}
run: |
version=$(./target/x86_64-unknown-linux-musl/release/en --version)
api_root=https://git.jutty.dev/api
url=$api_root/packages/jutty/generic/en/$version/en-x64-linux-musl
curl -fsSL \
--user jutty:${{ secrets.GJD_REGISTRY_TOKEN }} \
--upload-file target/x86_64-unknown-linux-musl/release/en $url

75
.forgejo/workflows/setup-tools.sh
View file

@ -1,75 +0,0 @@
#!/usr/bin/env sh
set -eu
JUST_VERSION="1.47.1"
JUST_SHA256SUM="3cb931ae25860f261ee373f32ede3b772ac91f14f588e4071576d3ffcf1a16fd"
CARGO_LLVM_COV_VERSION="0.6.21"
CARGO_LLVM_COV_SHA256SUM="57f491aedf7cdb261538ceb49cbb1ee9d27df7ca205a5e1a009caaf5cb911afb"
CARGO_AUDIT_VERSION="0.22.1"
CARGO_AUDIT_TAG="cargo-audit%2Fv$CARGO_AUDIT_VERSION"
CARGO_AUDIT_SHA256SUM="1890badd5f15831a9af4b074399fcd21e6f7c0fe42c84e9254cdffc9f813765c"
TAPLO_VERSION="0.10.0"
TAPLO_SHA256SUM="8fe196b894ccf9072f98d4e1013a180306e17d244830b03986ee5e8eabeb6156"
TYPOS_VERSION="1.47.2"
TYPOS_SHA256SUM="7aef58932fc123b4cf4b40d86468e89a3297d80169051d7cfd13a235e05fc426"
CARGO_DENY_VERSION="0.19.8"
CARGO_DENY_SHA256SUM="70e769ae3872e34d45132b17040859175e11401dc12dddb0303e0b8c7d088f3f"
TRIPLE="x86_64-unknown-linux-gnu"
TRIPLE_MUSL="x86_64-unknown-linux-musl"
fetch() {
repo="$1"
tag="$2"
filename="$3"
digest="$4"
binary="$5"
renamed_binary="${6:-$binary}"
[ -d /tmp/tools ] || mkdir -p /tmp/tools
curl -fsSLO --output-dir /tmp \
-w '%{stderr}HTTP %{response_code} %{url}\n' \
"https://github.com/$repo/releases/download/$tag/$filename"
printf '%s %s\n' "$digest" "/tmp/$filename" > /tmp/digest
sha256sum --check /tmp/digest
if printf '%s' "$filename" | grep -qE '\.tar\.|\.tgz$'; then
tar xf "/tmp/$filename" -C /tmp/tools
elif printf '%s' "$filename" | grep -q '\.gz$'; then
gunzip -c "/tmp/$filename" > "/tmp/tools/$binary"
else
echo "Fatal: can't determine how to unpack $filename"
exit 1
fi
find /tmp/tools -type f -name "$binary" \
-exec mv -v '{}' "/usr/local/bin/$renamed_binary" ';'
chmod +x "/usr/local/bin/$renamed_binary"
}
fetch casey/just "$JUST_VERSION" \
"just-$JUST_VERSION-$TRIPLE_MUSL.tar.gz" \
"$JUST_SHA256SUM" just
fetch taiki-e/cargo-llvm-cov "v$CARGO_LLVM_COV_VERSION" \
"cargo-llvm-cov-$TRIPLE.tar.gz" \
"$CARGO_LLVM_COV_SHA256SUM" cargo-llvm-cov
fetch rustsec/rustsec "$CARGO_AUDIT_TAG" \
"cargo-audit-$TRIPLE-v$CARGO_AUDIT_VERSION.tgz" \
"$CARGO_AUDIT_SHA256SUM" cargo-audit
fetch tamasfe/taplo "$TAPLO_VERSION" \
"taplo-linux-x86_64.gz" \
"$TAPLO_SHA256SUM" taplo-linux-x86_64 taplo
fetch crate-ci/typos "v$TYPOS_VERSION" \
"typos-v$TYPOS_VERSION-$TRIPLE_MUSL.tar.gz" \
"$TYPOS_SHA256SUM" typos
fetch EmbarkStudios/cargo-deny "$CARGO_DENY_VERSION" \
cargo-deny-$CARGO_DENY_VERSION-$TRIPLE_MUSL.tar.gz \
"$CARGO_DENY_SHA256SUM" cargo-deny

59
.forgejo/workflows/verify.yaml
View file

@ -1,59 +0,0 @@
on:
push:
branches:
- '*'
paths:
- src/**
- tests/**
- static/graph.toml
- .forgejo/**
- Cargo.toml
- Cargo.lock
jobs:
verify:
runs-on: docker
timeout-minutes: 20
container:
image: rust:slim
steps:
- name: Install action dependencies
run: apt-get install --no-install-recommends --update -y nodejs curl git
- name: Checkout code
uses: actions/checkout@v6
with:
fetch-tags: true
- name: Setup Rust toolchain
run: |
rustup component add llvm-tools-preview
rustup component add --toolchain nightly rustfmt clippy
rustup target add x86_64-unknown-linux-gnu
rustup target add x86_64-unknown-linux-musl
- name: Setup additional tooling
run: .forgejo/workflows/setup-tools.sh
- name: Setup CI user
run: |
useradd -m ci && chown -R ci:ci .
git config --global --add safe.directory "$PWD"
- name: Text matching checks
run: just ci todos-assess version-assess spell
- name: Schema lint
run: just ci schema-lint
- name: Deny
run: just ci deny
- name: Format
run: just ci format-assess
- name: Lint
run: just ci lint-assess
- name: Cargo check
run: just ci check
- name: Test
run: just ci test
- name: Assess test coverage
run: just ci cover-assess

1
.gitignore vendored
View file

@ -1,2 +1 @@
/target
/result

326
.justfile
View file

@ -5,6 +5,8 @@
update:
cargo update --verbose
alias u := update
# Build and serve
[group: 'develop']
run host='::1' port='3003' *args:
@ -16,108 +18,58 @@ alias r := run
# Build and serve on changes
[group: 'develop']
run-watch:
@{{ watch_cmd }} {{ just_cmd }} run
{{ watch_cmd }} {{ just_cmd }} run
alias w := run-watch
# Build on changes
[group: 'develop']
build-watch target=default_target:
@{{ watch_cmd }} {{ just_cmd }} build {{ target }}
alias bw := build-watch
# Build dev container
[group: 'develop', working-directory: 'containers']
build-containerized distro="alpine": build
./build.sh {{ distro }}-dev
alias bc := build-containerized
# Run dev container
[group: 'develop', working-directory: 'containers']
run-containerized distro="alpine":
./run.sh {{ distro }}-dev
alias rc := run-containerized
# Build dev container and serve from it on changes
[group: 'develop']
run-watch-containerized:
@{{ watch_cmd }} "{{ just_cmd }} build-containerized \
&& {{ just_cmd }} run-containerized"
alias wc := run-watch-containerized
[private]
quick-assess:
{{ just_cmd }} lint check quick-test-cover
[private]
assess-quick:
{{ just_cmd }} lint check test-cover-quick spell schema-lint
[private]
assess-run-quick:
-{{ just_cmd }} assess-quick
quick-assess-run:
-{{ just_cmd }} quick-assess
{{ just_cmd }} run
# Run quick assessments on changes
[group: 'develop']
assess-watch-quick:
{{ watch_cmd }} {{ just_cmd }} assess-quick
quick-assess-watch:
{{ watch_cmd }} {{ just_cmd }} quick-assess
alias aq := assess-watch-quick
alias qa := quick-assess-watch
# Run quick assessments, build and serve on changes
[group: 'develop']
assess-run-watch-quick:
{{ watch_cmd }} {{ just_cmd }} assess-run-quick
quick-assess-run-watch:
{{ watch_cmd }} {{ just_cmd }} quick-assess-run
alias rq := assess-run-watch-quick
alias qr := quick-assess-run-watch
[private]
test-cover-quick:
{{ cover_cmd }} --no-report -- --test 'serial_tests::' --test-threads 1
quick-test-cover:
{{ cover_cmd }} --no-report -- --skip 'serial_tests::'
{{ cover_cmd }} --no-report -- --test 'serial_tests::' --test-threads 1
{{ cover_cmd }} report --html
@{{ cover_cmd }} report | tail -1 | awk '{ print " [ Regions:", $4, "• Functions:", $7, "• Lines:", $10, "]" }'
# Quickly update coverage reports (inaccurate)
[group: 'assess']
test-cover-watch-quick:
@{{ watch_cmd }} {{ just_cmd_no_ts }} test-cover-quick 2>&1 \
| grep -v "process didn't exit successfully:" || true
quick-test-cover-watch:
{{ watch_cmd }} {{ just_cmd }} quick-test-cover
alias oq := test-cover-watch-quick
alias qo := quick-test-cover-watch
# Format all files
[group: 'develop']
format:
cargo +nightly fmt
cargo fmt
alias f := format
# Test (short output)
[group: 'develop']
test-short pattern="":
cargo test {{ pattern }} -q --message-format short \
-- 'serial_tests::' --test-threads=1 \
--format=terse -- quiet
cargo test {{ pattern }} -q --message-format short --bin en
cargo test {{ pattern }} -q --message-format short --doc
cargo test {{ pattern }} --message-format short --lib \
-- --format terse --skip 'serial_tests::'
alias ts := test-short
# Test on changes (shorter output)
[group: 'develop']
test-short-watch:
{{ watch_cmd }} {{ just_cmd }} test-short
alias tsw := test-short-watch
# Lint
[group: 'develop']
lint:
cargo +nightly clippy --timings --all-targets
cargo clippy
alias l := lint
@ -128,20 +80,6 @@ lint-watch:
alias lw := lint-watch
# Lint (short output)
[group: 'develop']
lint-short:
cargo +nightly clippy --all-targets -q --message-format short
alias ls := lint-short
# Lint on changes (shorter output)
[group: 'develop']
lint-short-watch:
{{ watch_cmd }} {{ just_cmd }} lint-short
alias lsw := lint-short-watch
# Run cargo check on changes
[group: 'develop']
check-watch:
@ -156,23 +94,16 @@ rustc-fix:
alias rf := rustc-fix
# Apply clippy lint fixes
[group: 'develop']
clippy-fix:
cargo +nightly clippy --fix --allow-dirty
alias cf := clippy-fix
# Apply all automatic fixes
[group: 'develop']
fix: rustc-fix clippy-fix format
fix: rustc-fix format
alias x := fix
# Run tests on changes
[group: 'develop']
test-watch pattern="":
{{ watch_cmd }} {{ just_cmd }} test {{ pattern}}
test-watch:
{{ watch_cmd }} {{ just_cmd }} test
alias tw := test-watch
@ -198,67 +129,24 @@ cover-open:
alias oo := cover-open
# Perform mutation testing
[group: 'develop']
mutate:
-just mutate-single -- --test-threads=1 serial_tests::
-just mutate-single -- --skip serial_tests::
alias m := mutate
[private]
mutate-single *cargo_test_args:
cargo mutants --iterate \
-E '<impl Debug<' \
-E '<impl From<' \
-E '<impl std::fmt::Display for ' \
-E 'print_help -> bool' \
--output target/mutants \
-- {{ cargo_test_args }}
# Tag HEAD with version from Cargo.toml
[script, group: 'assess']
tag commit="HEAD": update
if [ "{{ last_local_tag }}" = "{{ manifest_version }}" ]; then
echo "Last tag {{ last_local_tag }} and manifest ({{ manifest_version }}) already match"
exit
elif [ "{{ manifest_version }}" != "{{ lockfile_version }}" ]; then
echo "Manifest and lockfile versions don't match: update failed?"
exit 1
fi
git tag "v{{ manifest_version }}" {{ commit }}
{{ just_cmd }} version-assess
# Verify and push
[group: 'develop', env("JUST", "1")]
push: verify && (version-assess "true")
[group: 'develop']
push: verify
git push
git push --tags
alias p := push
# Push without verifying
[group: 'develop', env("JUST", "1")]
push-unsafe:
git push --no-verify
git push --tags --no-verify
alias pu := push-unsafe
# DOCUMENT
# Generate crate documentation
[group: 'document']
doc:
cargo doc --timings --document-private-items --no-deps
cargo doc --document-private-items --no-deps
alias d := doc
# Generate crate and dependencies documentation
[group: 'document']
doc-all:
cargo doc --timings --document-private-items
cargo doc --document-private-items
alias da := doc-all
@ -274,47 +162,34 @@ alias do := doc-open
# Assess formatting
[group: 'assess']
format-assess:
cargo +nightly fmt -- --check
cargo fmt -- --check
alias fa := format-assess
alias fc := format-assess
# Assess production lints
[group: 'assess']
lint-assess:
cargo +nightly clippy --timings -- \
-D clippy::print_stdout -D clippy::print_stderr \
-D clippy::dbg_macro -D clippy::use_debug
cargo +nightly clippy --timings --all-targets -- \
cargo clippy -- \
-D clippy::dbg_macro -D clippy::print_stdout -D clippy::print_stderr \
-D clippy::todo -D clippy::unimplemented -D clippy::unreachable
alias la := lint-assess
alias lp := lint-assess
# Run cargo check
[group: 'assess']
check:
{{ debug_vars }} cargo check --workspace --all-targets \
--future-incompat-report
{{ debug_vars }} cargo check --workspace
alias c := check
# Run tests
[group: 'assess']
test pattern="":
cargo test {{ pattern}} --timings -- --test-threads=1 'serial_tests::'
cargo test {{ pattern}} --timings --bin en
cargo test {{ pattern}} --timings --doc
cargo test {{ pattern}} --timings --lib -- --skip 'serial_tests::'
test:
cargo test -- --skip 'serial_tests::'
cargo test -- --test 'serial_tests::' --test-threads 1
alias t := test
# Run tests with unfiltered output
[group: 'assess']
test-output pattern="":
DEBUG=${DEBUG:-debug} cargo test {{ pattern }} -- --no-capture 2>&1
alias to := test-output
# Clean test coverage data
[group: 'assess']
test-cover-clean:
@ -325,8 +200,8 @@ alias oc := test-cover-clean
# Run tests with coverage
[group: 'assess']
test-cover: test-cover-clean
{{ cover_cmd }} --no-report -- --test 'serial_tests::' --test-threads 1
{{ cover_cmd }} --no-report -- --skip 'serial_tests::'
{{ cover_cmd }} --no-report -- --test 'serial_tests::' --test-threads 1
alias o := test-cover
@ -343,60 +218,12 @@ verify:
export RUSTFLAGS=${RUSTFLAGS:-"-Dwarnings"}
if [ -n "$(git status --porcelain)" ]; then
echo "Git working tree is dirty: Commit or stash your changes first"
git status
exit 1
fi
{{ just_cmd }} \
todos-assess version-assess spell schema-lint deny \
format-assess lint-assess check \
test "" cover-assess
{{ just_cmd }} format-assess lint-assess check test cover-assess
alias v := verify
# Check tag-manifest consistency
[script, group: 'assess']
[arg("remote", long="remote", short="r", value="true")]
version-assess remote="false": update
last_remote_tag=$(
git ls-remote --tags --sort=-creatordate origin |
head -n 1 | tr -d v | cut -d / -f 3
)
printf 'Local: %s\nRemote: %s\nManifest: %s\nLockfile: %s\n' \
"{{ last_local_tag }}" \
"$last_remote_tag" \
"{{ manifest_version }}" \
"{{ lockfile_version }}"
test "{{ last_local_tag }}" = "{{ lockfile_version }}"
test "{{ last_local_tag }}" = "{{ manifest_version }}"
if {{ if remote == "true" { "true" } else { "false" } }}; then
test "{{ last_local_tag }}" = "$last_remote_tag"
fi
alias va := version-assess
# Find TODOs
[group: 'assess']
todos-assess:
! grep -rn TODO src
alias ta := todos-assess
# Check for security advisories, unexpected licenses, allowed registries
[group: 'assess']
deny:
cargo-deny check
# Check for spelling mistakes
[group: 'assess']
spell:
typos
# Lint the default and builtin graphs against the schema
[group: 'assess']
schema-lint:
test -z "$(grep -LF '#:schema ./graph-schema.json' static/*.toml)"
taplo lint static/*.toml
# BUILD
# Cleanup build artifacts
@ -406,56 +233,25 @@ clean:
alias cl := clean
# Build
# Build project with Cargo
[group: 'build']
build target=default_target:
cargo build --timings --target {{ target }} --locked
build: update
cargo build
alias b := build
# glibc build
[group: 'build']
build-gnu:
cargo build --timings --target {{ glibc_target }} --locked
alias bg := build-gnu
# musl build
[group: 'build']
build-musl:
cargo build --timings --target {{ musl_target }} --locked
alias bm := build-musl
# Release build
[group: 'build']
release-build target=default_target:
cargo build --timings --target {{ target }} --locked --release
du -h target/{{ target }}/release/en
release-build: update verify
cargo build --release
alias rb := release-build
# glibc release build
# Clean, run assessments, release build
[group: 'build']
release-build-gnu:
{{ just_cmd }} release-build {{ glibc_target }}
full-build: clean update verify release-build
alias rbg := release-build-gnu
# musl release build
[group: 'build']
release-build-musl:
{{ just_cmd }} release-build {{ musl_target }}
alias rbm := release-build-musl
# Calculate SHA 256 hashes for release binaries
[group: 'build']
shasum:
find target -type d -name 'release' \
-exec find '{}' -maxdepth 1 -type f -name en -executable ';' \
| xargs sha256sum
alias fb := full-build
## META
@ -463,37 +259,11 @@ shasum:
default:
@just --list --unsorted --justfile {{justfile()}}
choose:
@just --choose
alias ch := choose
[script, private, env("CARGO_HOME", "$HOME/.cargo")]
ci recipe:
su ci -c "just {{ recipe }}"
## VARIABLES
export CARGO_TERM_COLOR := 'always'
musl_target := "x86_64-unknown-linux-musl"
glibc_target := "x86_64-unknown-linux-gnu"
default_target := musl_target
debug_vars := 'DEBUG=${DEBUG:-} DEBUG_FILTER=${DEBUG_FILTER:-} RUST_BACKTRACE=${RUST_BACKTRACE:-} RUSTFLAGS=${RUSTFLAGS:-}'
watch_cmd := "watchexec -qc -r -e rs,toml,html --color always -- "
cover_cmd := 'cargo llvm-cov --color always --ignore-filename-regex "main\.rs|dev\.rs"'
just_cmd := 'just --timestamp --explain --command-color green'
just_cmd_no_ts := 'just --explain --command-color green'
watch_cmd := "watchexec -qc -r -e rs,toml,html,css --color always -- "
cover_cmd := 'cargo llvm-cov --color always --ignore-filename-regex "main\.rs|log\.rs"'
last_local_tag := `git tag --sort=-creatordate | head -n 1 | tr -d v`
manifest_version := `grep "^version" Cargo.toml | cut -d \" -f 2`
lockfile_version := ```
grep -A 1 'name = "en"' Cargo.lock \
| grep version | cut -d '"' -f 2
```
## OPTIONS
set unstable
set lazy

50
.rustfmt.toml
View file

@ -1,33 +1,25 @@
unstable_features = true
max_width = 80
inline_attribute_width = 40
skip_macro_invocations = ["concat"]
imports_granularity = "Crate"
group_imports = "StdExternalCrate"
fn_single_line = true
match_block_trailing_comma = true
max_width = 80
reorder_imports = false
reorder_modules = false
use_field_init_shorthand = true
use_try_shorthand = true
hex_literal_case = "Lower"
where_single_line = true
condense_wildcard_suffixes = true
combine_control_expr = false
empty_item_single_line = true
reorder_impl_items = true
trailing_semicolon = false
wrap_comments = true
normalize_comments = true
normalize_doc_attributes = true
format_code_in_doc_comments = true
doc_comment_code_block_width = 70
error_on_unformatted = true
error_on_line_overflow = true
ignore = [
"tests/mocks",
]
# blank_lines_lower_bound = 1
# not stabilized yet
# where_single_line = true
# overflow_delimited_expr = true
# normalize_doc_attributes = true
# normalize_comments = true
# inline_attribute_width = 40
# imports_granularity = "Crate"
# hex_literal_case = "Lower"
# group_imports = "StdExternalCrate"
# format_strings = true
# force_multiline_blocks = true
# error_on_unformatted = true
# error_on_line_overflow = true
# condense_wildcard_suffixes = true
# doc_comment_code_block_width = 70
# format_code_in_doc_comments = true
# wrap_comments = true

598
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

238
Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "en"
version = "0.4.0-alpha"
version = "0.1.0"
description = "A non-linear writing instrument."
license = "AGPL-3.0-only"
@ -9,7 +9,7 @@ homepage = "https://en.jutty.dev"
documentation = "https://en.jutty.dev/node/Documentation"
edition = "2024"
rust-version= "1.94.0"
rust-version= "1.91.1"
[features]
serial-tests = []
@ -23,6 +23,7 @@ serde = { version = "1.0.228", features = ["derive"] }
toml = "0.9.8"
[dev-dependencies]
ureq = "3"
tower = { version = "0.5.2", features = ["util"] }
[lints.rust]
@ -33,269 +34,176 @@ let_underscore= { level = "warn", priority = 10 }
nonstandard-style = "warn"
future-incompatible = "warn"
keyword-idents = "warn"
non_ascii_idents = "warn"
[lints.clippy]
# levels: allow, warn, deny, forbid
allow_attributes = "warn"
arithmetic_side_effects = "warn"
as_conversions = "warn"
as_pointer_underscore = "warn"
as_underscore = "warn"
manual_non_exhaustive = "allow"
collapsible_if = "allow"
collapsible_else_if = "allow"
field_reassign_with_default = "allow"
# pedantic
assigning_clones = "warn"
branches_sharing_code = "warn"
case_sensitive_file_extension_comparisons = "warn"
borrow_as_ptr = "warn"
cast_lossless = "warn"
cast_possible_truncation = "warn"
cast_possible_wrap = "warn"
cast_precision_loss = "warn"
cast_ptr_alignment = "warn"
cast_sign_loss = "warn"
checked_conversions = "warn"
clear_with_drain = "warn"
cloned_instead_of_copied = "warn"
cmp_owned = "warn"
coerce_container_to_any = "warn"
collapsible_else_if = "allow"
collapsible_if = "allow"
collection_is_never_read = "warn"
comparison_chain = "warn"
copy_iterator = "warn"
default_trait_access = "warn"
deref_by_slicing = "warn"
derive_partial_eq_without_eq = "warn"
doc_broken_link = "warn"
doc_comment_double_space_linebreaks = "warn"
doc_include_without_cfg = "warn"
doc_link_code = "warn"
doc_link_with_quotes = "warn"
doc_markdown = "warn"
doc_paragraphs_missing_punctuation = "warn"
double_must_use = "warn"
duration_suboptimal_units = "warn"
empty_drop = "warn"
empty_enum_variants_with_brackets = "warn"
empty_enums = "warn"
empty_structs_with_brackets = "warn"
equatable_if_let = "warn"
error_impl_error = "warn"
exit = "warn"
expect_used = "warn"
empty_enum = "warn"
enum_glob_use = "warn"
expl_impl_clone_on_copy = "warn"
explicit_counter_loop = "warn"
explicit_deref_methods = "warn"
explicit_into_iter_loop = "warn"
explicit_iter_loop = "warn"
fallible_impl_from = "warn"
field_reassign_with_default = "allow"
filetype_is_file = "warn"
filter_map_next = "warn"
flat_map_option = "warn"
float_cmp = "warn"
float_cmp_const = "warn"
fn_to_numeric_cast_any = "warn"
format_collect = "warn"
format_push_string = "warn"
from_iter_instead_of_collect = "warn"
get_unwrap = "warn"
if_not_else = "warn"
if_then_some_else_none = "warn"
ignore_without_reason = "warn"
ignored_unit_patterns = "warn"
implicit_clone = "warn"
implicit_hasher = "warn"
imprecise_flops = "warn"
inconsistent_struct_constructor = "warn"
index_refutable_slice = "warn"
indexing_slicing = "warn"
inefficient_to_string = "warn"
infinite_loop = "warn"
int_plus_one = "warn"
integer_division = "warn"
integer_division_remainder_used = "warn"
into_iter_without_iter = "warn"
invalid_upcast_comparisons = "warn"
ip_constant = "warn"
iter_filter_is_ok = "warn"
iter_filter_is_some = "warn"
iter_kv_map = "warn"
iter_not_returning_iterator = "warn"
iter_on_empty_collections = "warn"
iter_on_single_items = "warn"
iter_with_drain = "warn"
iter_without_into_iter = "warn"
large_digit_groups = "warn"
large_futures = "warn"
large_stack_arrays = "warn"
large_types_passed_by_value = "warn"
let_underscore_must_use = "warn"
linkedlist = "warn"
literal_string_with_formatting_args = "warn"
lossy_float_literal = "warn"
macro_use_imports = "warn"
manual_assert = "warn"
manual_checked_ops = "warn"
manual_ilog2 = "warn"
manual_instant_elapsed = "warn"
manual_is_multiple_of = "warn"
manual_is_power_of_two = "warn"
manual_is_variant_and = "warn"
manual_let_else = "warn"
manual_midpoint = "warn"
manual_non_exhaustive = "allow"
manual_option_zip = "warn"
manual_pop_if = "warn"
manual_string_new = "warn"
manual_take = "warn"
many_single_char_names = "warn"
map_err_ignore = "warn"
map_with_unused_argument_over_ranges = "warn"
map_unwrap_or = "warn"
match_bool = "warn"
match_same_arms = "warn"
match_wild_err_arm = "warn"
match_wildcard_for_single_variants = "warn"
maybe_infinite_iter = "warn"
mem_forget = "warn"
mismatching_type_param_order = "warn"
missing_assert_message = "warn"
missing_asserts_for_indexing = "warn"
missing_const_for_fn = "warn"
missing_errors_doc = "warn"
missing_fields_in_debug = "warn"
missing_panics_doc = "warn"
mixed_read_write_in_expression = "warn"
mod_module_files = "warn"
module_name_repetitions = "warn"
multiple_inherent_impl = "warn"
mut_mut = "warn"
mutex_atomic = "warn"
mutex_integer = "warn"
naive_bytecount = "warn"
needless_collect = "warn"
needless_continue = "warn"
needless_for_each = "warn"
needless_pass_by_ref_mut = "warn"
needless_pass_by_value = "warn"
needless_raw_string_hashes = "warn"
needless_raw_strings = "warn"
needless_type_cast = "warn"
no_effect_underscore_binding = "warn"
non_send_fields_in_send_ty = "warn"
non_std_lazy_statics = "warn"
non_zero_suggestions = "warn"
nonstandard_macro_braces = "warn"
option_as_ref_cloned = "warn"
option_option = "warn"
panic_in_result_fn = "warn"
path_buf_push_overwrite = "warn"
pathbuf_init_then_push = "warn"
possible_missing_else = "warn"
ptr_as_ptr = "warn"
ptr_cast_constness = "warn"
pub_underscore_fields = "warn"
pub_without_shorthand = "warn"
question_mark = "warn"
range_minus_one = "warn"
range_plus_one = "warn"
rc_buffer = "warn"
rc_mutex = "warn"
read_zero_byte_vec = "warn"
redundant_clone = "warn"
redundant_closure = "warn"
redundant_closure_for_method_calls = "warn"
redundant_iter_cloned = "warn"
redundant_pub_crate = "warn"
redundant_test_prefix = "warn"
redundant_type_annotations = "warn"
ref_as_ptr = "warn"
ref_binding_to_reference = "warn"
ref_option = "warn"
ref_option_ref = "warn"
renamed_function_params = "warn"
replace_box = "warn"
rest_pat_in_fully_bound_structs = "warn"
return_and_then = "warn"
return_self_not_must_use = "warn"
same_functions_in_if_condition = "warn"
same_length_and_capacity = "warn"
same_name_method = "warn"
search_is_some = "warn"
self_only_used_in_recursion = "warn"
semicolon_if_nothing_returned = "warn"
semicolon_inside_block = "warn"
set_contains_or_insert = "warn"
shadow_reuse = "warn"
shadow_same = "warn"
shadow_unrelated = "warn"
should_panic_without_expect = "warn"
single_char_pattern = "warn"
single_match_else = "warn"
single_option_map = "warn"
stable_sort_primitive = "warn"
similar_names = "warn"
str_split_at_newline = "warn"
string_add = "warn"
string_add_assign = "warn"
string_lit_as_bytes = "warn"
string_lit_chars_any = "warn"
string_slice = "warn"
struct_field_names = "warn"
suboptimal_flops = "warn"
suspicious_operation_groupings = "warn"
suspicious_xor_used_as_pow = "warn"
tests_outside_test_module = "warn"
too_long_first_doc_paragraph = "warn"
trait_duplication_in_bounds = "warn"
trivially_copy_pass_by_ref = "warn"
try_err = "warn"
tuple_array_conversions = "warn"
type_repetition_in_bounds = "warn"
unchecked_time_subtraction = "warn"
unicode_not_nfc = "warn"
uninlined_format_args = "warn"
unnecessary_box_returns = "warn"
unnecessary_cast = "warn"
unnecessary_debug_formatting = "warn"
unnecessary_fold = "warn"
unnecessary_join = "warn"
unnecessary_literal_bound = "warn"
unnecessary_option_map_or_else = "warn"
unnecessary_result_map_or_else = "warn"
unnecessary_self_imports = "warn"
unnecessary_semicolon = "warn"
unnecessary_struct_initialization = "warn"
unnecessary_trailing_comma = "warn"
unnecessary_wraps = "warn"
unneeded_field_pattern = "warn"
unnested_or_patterns = "warn"
unreadable_literal = "warn"
unsafe_derive_deserialize = "warn"
unseparated_literal_suffix = "warn"
unused_async = "warn"
unused_peekable = "warn"
unused_result_ok = "warn"
unused_rounding = "warn"
unused_self = "warn"
unused_trait_names = "warn"
unwrap_in_result = "warn"
unwrap_used = "warn"
used_underscore_binding = "warn"
used_underscore_items = "warn"
useless_concat = "warn"
useless_conversion = "warn"
useless_let_if_seq = "warn"
verbose_file_reads = "warn"
volatile_composites = "warn"
wildcard_enum_match_arm = "warn"
wildcard_imports = "warn"
zero_sized_map_values = "warn"
# restrictive
arithmetic_side_effects = "warn"
as_conversions = "warn"
as_pointer_underscore = "warn"
as_underscore = "warn"
deref_by_slicing = "warn"
empty_drop = "warn"
empty_enum_variants_with_brackets = "warn"
error_impl_error = "warn"
exit = "warn"
expect_used = "warn"
filetype_is_file = "warn"
float_cmp_const = "warn"
fn_to_numeric_cast_any = "warn"
if_then_some_else_none = "warn"
indexing_slicing = "warn"
infinite_loop = "warn"
integer_division = "warn"
integer_division_remainder_used = "warn"
let_underscore_must_use = "warn"
let_underscore_untyped = "warn"
lossy_float_literal = "warn"
map_err_ignore = "warn"
map_with_unused_argument_over_ranges = "warn"
missing_assert_message = "warn"
missing_asserts_for_indexing = "warn"
mixed_read_write_in_expression = "warn"
module_name_repetitions = "warn"
multiple_inherent_impl = "warn"
needless_raw_strings = "warn"
non_zero_suggestions = "warn"
panic_in_result_fn = "warn"
pathbuf_init_then_push = "warn"
pub_without_shorthand = "warn"
redundant_test_prefix = "warn"
redundant_type_annotations = "warn"
renamed_function_params = "warn"
rest_pat_in_fully_bound_structs = "warn"
return_and_then = "warn"
same_name_method = "warn"
semicolon_outside_block = "warn"
shadow_reuse = "warn"
shadow_same = "warn"
shadow_unrelated = "warn"
string_add = "warn"
string_lit_chars_any = "warn"
unnecessary_self_imports = "warn"
unneeded_field_pattern = "warn"
unseparated_literal_suffix = "warn"
unused_result_ok = "warn"
unused_trait_names = "warn"
unwrap_used = "warn"
verbose_file_reads = "warn"
wildcard_enum_match_arm = "warn"
# cargo
negative_feature_names = "warn"
redundant_feature_names = "warn"
wildcard_dependencies = "warn"
[package.metadata.typos.default]
extend-ignore-re = [
"oficial do Brasil",
"Creative Commons ND",
"Creative Commons BY-ND",
"CC_BY_ND_",
"(?ms)^mod tests \\{.*^\\}",
]

17
README.md
View file

@ -1,19 +1,14 @@
# en
en is a tool to write non-linear, connected pieces of text and have their references mapped out as a metadata-rich graph of connected information.
en is a tool to write non-linear, connected pieces of text and have their references mapped out as a graph of connected information.
It works by ingesting a graph definition that leverages TOML for metadata and a special markup language for prose. en can then serve this textual representation as a website (with other targets planned) that allows nodes to be explored.
It works by ingesting a TOML file containing your node specification and serving it as a website that allows nodes to be browsed, searched and listed in relation to each other or as a shallow tree of nodes.
## Roadmap
For an outline of planned and completed features, see the [roadmap](https://en.jutty.dev/node/Roadmap).
## Learn more
You can learn more and see what en looks like by visiting the [homepage](https://en.jutty.dev), which is rendered using en itself.
## Install and run
See the [Get Started](https://en.jutty.dev/node/GetStarted) page for instructions and how to install and start using en.
## Roadmap
For a high-level view of what's in the future for en, see the [What's ahead section](https://en.jutty.dev/node/Introduction#What's) of the docs Introduction.
For a more detailed outline of what's planned, along with what's already been completed, see the [roadmap](https://en.jutty.dev/node/Roadmap).

36
containers/Containerfile.alpine
View file

@ -1,36 +0,0 @@
FROM alpine:latest
MAINTAINER Juno Takano juno@jutty.dev
ENV DEBUG=debug
# Setup tooling
RUN apk add curl clang git file
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
# Install
RUN <<EOF
REPO_URL=https://codeberg.org/jutty/en
LAST_TAG=$(
git ls-remote --tags "$REPO_URL" \
| grep refs/tags \
| sed 's/.*refs\/tags\///' \
| sort -V \
| tail -n 1
)
git config --global advice.detachedHead false
echo "Selected tag: $LAST_TAG"
git clone --verbose -b "$LAST_TAG" \
--depth 1 --single-branch --no-tags \
"$REPO_URL" /build
EOF
RUN <<EOF
cd /build && /root/.cargo/bin/cargo build --locked --release
mv /build/target/release/en /usr/local/bin/en
rm -rf /build
EOF
# Describe
RUN file $(which en) && sha256sum $(which en)
# Launch
WORKDIR /root
CMD ["en", "-p", "80"]

13
containers/Containerfile.alpine-dev
View file

@ -1,13 +0,0 @@
FROM docker.io/library/rust:alpine
MAINTAINER Juno Takano juno@jutty.dev
ENV DEBUG=debug
# Install
COPY en /usr/local/bin/en
# Describe
RUN sha256sum $(which en)
# Launch
WORKDIR /root
CMD ["en", "-p", "80"]

37
containers/Containerfile.debian
View file

@ -1,37 +0,0 @@
FROM debian:stable-slim
MAINTAINER Juno Takano juno@jutty.dev
ENV DEBUG=debug
# Setup tooling
RUN apt-get -y --update install --no-install-recommends \
curl ca-certificates gcc libc6-dev git file
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
# Install
RUN <<EOF
REPO_URL=https://codeberg.org/jutty/en
LAST_TAG=$(
git ls-remote --tags "$REPO_URL" \
| grep refs/tags \
| sed 's/.*refs\/tags\///' \
| sort -V \
| tail -n 1
)
git config --global advice.detachedHead false
echo "Selected tag: $LAST_TAG"
git clone --verbose -b "$LAST_TAG" \
--depth 1 --single-branch --no-tags \
"$REPO_URL" /build
EOF
RUN <<EOF
cd /build && /root/.cargo/bin/cargo build --locked --release
mv /build/target/release/en /usr/local/bin/en
rm -rf /build
EOF
# Describe
RUN file $(which en) && sha256sum $(which en)
# Launch
WORKDIR /root
CMD ["en", "-p", "80"]

13
containers/Containerfile.debian-dev
View file

@ -1,13 +0,0 @@
FROM debian:stable-slim
MAINTAINER Juno Takano juno@jutty.dev
ENV DEBUG=debug
# Install
COPY en /usr/local/bin/en
# Describe
RUN sha256sum $(which en)
# Launch
WORKDIR /root
CMD ["en", "-p", "80"]

2
containers/README.md
View file

@ -1,2 +0,0 @@
## Known issues
- Containers will halt and fail to respond to requests with `ERR_CONNECTION_RESET` if the working directory is `/`

24
containers/build.sh
View file

@ -1,24 +0,0 @@
#!/usr/bin/env sh
set -eu
suffix=$(printf '%s' "$1" | sed 's/.*\.//')
tag="en:$suffix"
shift
if podman container exists "$tag"; then
podman stop --time 3 "$tag"
fi
if [ "$suffix" = 'debian-dev' ]; then
cp -v ../target/x86_64-unknown-linux-gnu/debug/en en
elif [ "$suffix" = 'alpine-dev' ]; then
cp -v ../target/x86_64-unknown-linux-musl/debug/en en
fi
podman build \
--tag "$tag" \
-f "Containerfile.$suffix" "$@"
if [ -f en ]; then
rm -v en
fi

15
containers/run.sh
View file

@ -1,15 +0,0 @@
#!/usr/bin/env sh
set -eu
suffix=$(printf '%s' "$1" | sed 's/.*\.//')
name="en-$suffix"
tag="en:$suffix"
shift
podman run \
--replace \
--name "$name" \
--publish 3008:80 \
--init \
"$@" \
"$tag"

243
deny.toml
View file

@ -1,243 +0,0 @@
# This template contains all of the possible sections and their default values
# Note that all fields that take a lint level have these possible values:
# * deny - An error will be produced and the check will fail
# * warn - A warning will be produced, but the check will not fail
# * allow - No warning or error will be produced, though in some cases a note
# will be
# The values provided in this template are the default values that will be used
# when any section or field is not specified in your own configuration
# Root options
# The graph table configures how the dependency graph is constructed and thus
# which crates the checks are performed against
[graph]
# If 1 or more target triples (and optionally, target_features) are specified,
# only the specified targets will be checked when running `cargo deny check`.
# This means, if a particular package is only ever used as a target specific
# dependency, such as, for example, the `nix` crate only being used via the
# `target_family = "unix"` configuration, that only having windows targets in
# this list would mean the nix crate, as well as any of its exclusive
# dependencies not shared by any other crates, would be ignored, as the target
# list here is effectively saying which targets you are building for.
targets = [
# The triple can be any string, but only the target triples built in to
# rustc (as of 1.40) can be checked against actual config expressions
#"x86_64-unknown-linux-musl",
# You can also specify which target_features you promise are enabled for a
# particular target. target_features are currently not validated against
# the actual valid features supported by the target architecture.
#{ triple = "wasm32-unknown-unknown", features = ["atomics"] },
]
# When creating the dependency graph used as the source of truth when checks are
# executed, this field can be used to prune crates from the graph, removing them
# from the view of cargo-deny. This is an extremely heavy hammer, as if a crate
# is pruned from the graph, all of its dependencies will also be pruned unless
# they are connected to another crate in the graph that hasn't been pruned,
# so it should be used with care. The identifiers are [Package ID Specifications]
# (https://doc.rust-lang.org/cargo/reference/pkgid-spec.html)
#exclude = []
# If true, metadata will be collected with `--all-features`. Note that this can't
# be toggled off if true, if you want to conditionally enable `--all-features` it
# is recommended to pass `--all-features` on the cmd line instead
all-features = false
# If true, metadata will be collected with `--no-default-features`. The same
# caveat with `all-features` applies
no-default-features = false
# If set, these feature will be enabled when collecting metadata. If `--features`
# is specified on the cmd line they will take precedence over this option.
#features = []
# The output table provides options for how/if diagnostics are outputted
[output]
# When outputting inclusion graphs in diagnostics that include features, this
# option can be used to specify the depth at which feature edges will be added.
# This option is included since the graphs can be quite large and the addition
# of features from the crate(s) to all of the graph roots can be far too verbose.
# This option can be overridden via `--feature-depth` on the cmd line
feature-depth = 1
# This section is considered when running `cargo deny check advisories`
# More documentation for the advisories section can be found here:
# https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
[advisories]
# The path where the advisory databases are cloned/fetched into
#db-path = "$CARGO_HOME/advisory-dbs"
# The url(s) of the advisory databases to use
#db-urls = ["https://github.com/rustsec/advisory-db"]
# A list of advisory IDs to ignore. Note that ignored advisories will still
# output a note when they are encountered.
ignore = [
#"RUSTSEC-0000-0000",
#{ id = "RUSTSEC-0000-0000", reason = "you can specify a reason the advisory is ignored" },
#"a-crate-that-is-yanked@0.1.1", # you can also ignore yanked crate versions if you wish
#{ crate = "a-crate-that-is-yanked@0.1.1", reason = "you can specify why you are ignoring the yanked crate" },
]
# If this is true, then cargo deny will use the git executable to fetch advisory database.
# If this is false, then it uses a built-in git library.
# Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support.
# See Git Authentication for more information about setting up git authentication.
#git-fetch-with-cli = true
# This section is considered when running `cargo deny check licenses`
# More documentation for the licenses section can be found here:
# https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
[licenses]
# List of explicitly allowed licenses
# See https://spdx.org/licenses/ for list of possible licenses
# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
allow = [
"MIT",
"BSD-2-Clause",
"BSD-3-Clause",
"Apache-2.0",
"Apache-2.0 WITH LLVM-exception",
"AGPL-3.0-only",
"Unicode-3.0",
]
# The confidence threshold for detecting a license from license text.
# The higher the value, the more closely the license text must be to the
# canonical license text of a valid SPDX license file.
# [possible values: any between 0.0 and 1.0].
confidence-threshold = 0.8
# Allow 1 or more licenses on a per-crate basis, so that particular licenses
# aren't accepted for every possible crate as with the normal allow list
exceptions = [
# Each entry is the crate and version constraint, and its specific allow
# list
#{ allow = ["Zlib"], crate = "adler32" },
]
# Some crates don't have (easily) machine readable licensing information,
# adding a clarification entry for it allows you to manually specify the
# licensing information
#[[licenses.clarify]]
# The package spec the clarification applies to
#crate = "ring"
# The SPDX expression for the license requirements of the crate
#expression = "MIT AND ISC AND OpenSSL"
# One or more files in the crate's source used as the "source of truth" for
# the license expression. If the contents match, the clarification will be used
# when running the license check, otherwise the clarification will be ignored
# and the crate will be checked normally, which may produce warnings or errors
# depending on the rest of your configuration
#license-files = [
# Each entry is a crate relative path, and the (opaque) hash of its contents
#{ path = "LICENSE", hash = 0xbd0eed23 }
#]
[licenses.private]
# If true, ignores workspace crates that aren't published, or are only
# published to private registries.
# To see how to mark a crate as unpublished (to the official registry),
# visit https://doc.rust-lang.org/cargo/reference/manifest.html#the-publish-field.
ignore = false
# One or more private registries that you might publish crates to, if a crate
# is only published to private registries, and ignore is true, the crate will
# not have its license(s) checked
registries = [
#"https://sekretz.com/registry
]
# This section is considered when running `cargo deny check bans`.
# More documentation about the 'bans' section can be found here:
# https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html
[bans]
# Lint level for when multiple versions of the same crate are detected
multiple-versions = "warn"
# Lint level for when a crate version requirement is `*`
wildcards = "allow"
# The graph highlighting used when creating dotgraphs for crates
# with multiple versions
# * lowest-version - The path to the lowest versioned duplicate is highlighted
# * simplest-path - The path to the version with the fewest edges is highlighted
# * all - Both lowest-version and simplest-path are used
highlight = "all"
# The default lint level for `default` features for crates that are members of
# the workspace that is being checked. This can be overridden by allowing/denying
# `default` on a crate-by-crate basis if desired.
workspace-default-features = "allow"
# The default lint level for `default` features for external crates that are not
# members of the workspace. This can be overridden by allowing/denying `default`
# on a crate-by-crate basis if desired.
external-default-features = "allow"
# List of crates that are allowed. Use with care!
allow = [
#"ansi_term@0.11.0",
#{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is allowed" },
]
# If true, workspace members are automatically allowed even when using deny-by-default
# This is useful for organizations that want to deny all external dependencies by default
# but allow their own workspace crates without having to explicitly list them
allow-workspace = false
# List of crates to deny
deny = [
#"ansi_term@0.11.0",
#{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is banned" },
# Wrapper crates can optionally be specified to allow the crate when it
# is a direct dependency of the otherwise banned crate
#{ crate = "ansi_term@0.11.0", wrappers = ["this-crate-directly-depends-on-ansi_term"] },
]
# List of features to allow/deny
# Each entry the name of a crate and a version range. If version is
# not specified, all versions will be matched.
#[[bans.features]]
#crate = "reqwest"
# Features to not allow
#deny = ["json"]
# Features to allow
#allow = [
# "rustls",
# "__rustls",
# "__tls",
# "hyper-rustls",
# "rustls",
# "rustls-pemfile",
# "rustls-tls-webpki-roots",
# "tokio-rustls",
# "webpki-roots",
#]
# If true, the allowed features must exactly match the enabled feature set. If
# this is set there is no point setting `deny`
#exact = true
# Certain crates/versions that will be skipped when doing duplicate detection.
skip = [
#"ansi_term@0.11.0",
#{ crate = "ansi_term@0.11.0", reason = "you can specify a reason why it can't be updated/removed" },
]
# Similarly to `skip` allows you to skip certain crates during duplicate
# detection. Unlike skip, it also includes the entire tree of transitive
# dependencies starting at the specified crate, up to a certain depth, which is
# by default infinite.
skip-tree = [
#"ansi_term@0.11.0", # will be skipped along with _all_ of its direct and transitive dependencies
#{ crate = "ansi_term@0.11.0", depth = 20 },
]
# This section is considered when running `cargo deny check sources`.
# More documentation about the 'sources' section can be found here:
# https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html
[sources]
# Lint level for what to happen when a crate from a crate registry that is not
# in the allow list is encountered
unknown-registry = "warn"
# Lint level for what to happen when a crate from a git repository that is not
# in the allow list is encountered
unknown-git = "warn"
# List of URLs for allowed crate registries. Defaults to the crates.io index
# if not specified. If it is specified but empty, no registries are allowed.
allow-registry = ["https://github.com/rust-lang/crates.io-index"]
# List of URLs for allowed Git repositories
allow-git = []
[sources.allow-org]
# github.com organizations to allow git sources for
github = []
# gitlab.com organizations to allow git sources for
gitlab = []
# bitbucket.org organizations to allow git sources for
bitbucket = []

26
flake.lock generated
View file

@ -1,26 +0,0 @@
{
"nodes": {
"nixpkgs": {
"locked": {
"lastModified": 1780453794,
"narHash": "sha256-bXMRa9VTsHSPXL4Cw8R6JJLQeY3Y/IP4+YJCYVmQ7FY=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "6b316287bae2ee04c9b93c8c858d930fd07d7338",
"type": "github"
},
"original": {
"id": "nixpkgs",
"ref": "nixos-26.05",
"type": "indirect"
}
},
"root": {
"inputs": {
"nixpkgs": "nixpkgs"
}
}
},
"root": "root",
"version": 7
}

80
flake.nix
View file

@ -1,80 +0,0 @@
{
description = "A non-linear writing instrument.";
inputs.nixpkgs.url = "nixpkgs/nixos-26.05";
outputs = { nixpkgs, self }: let
name = "en";
version = "0.4.0";
supportedSystems = [
"x86_64-linux"
"aarch64-linux"
];
forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
nixpkgsFor = forAllSystems (system: import nixpkgs {
inherit system;
});
in {
packages = forAllSystems (system: let
pkgs = nixpkgsFor.${system};
in {
default = pkgs.rustPlatform.buildRustPackage {
inherit name version;
src = ./.;
cargoHash =
"sha256-"
+ "em229cShq/IShRnxlp5mgcIu7pIOf0LflV8Pw0lLUEY=";
};
});
apps = forAllSystems (system: {
default = {
type = "app";
program =
"${self.packages.${system}.default}/bin/en";
};
});
devShells = forAllSystems (system:
let pkgs = nixpkgsFor.${system}; in {
default = pkgs.mkShell {
buildInputs = with pkgs; [
rustup
just
watchexec
cargo-deny
cargo-llvm-cov
cargo-mutants
go-tools
typos
taplo
];
};
}
);
nixosModules.bot = { config, lib, system, ... }: {
options.within.services.en.enable =
lib.mkEnableOption "enable en server";
config = lib.mkIf config.within.services.en.enable {
systemd.services.en = {
wantedBy = [ "multi-user.target" ];
serviceConfig = {
Restart = "always";
ExecStart =
"${self.packages."${system}".default}/bin/en";
};
};
};
};
};
}

2
src/dev.rs
View file

@ -1,2 +0,0 @@
pub mod log;
pub mod test;

194
src/dev/log/level.rs
View file

@ -1,194 +0,0 @@
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
#[repr(u16)]
pub enum Level {
SILENT = 0,
FATAL = 1,
ERROR = 2,
WARN = 3,
INFO = 4,
DEBUG = 5,
VERBOSE = 6,
TRACE = 7,
META = 37,
}
pub const ENV_DEFAULT: Level = Level::WARN;
pub const MESSAGE_DEFAULT: Level = Level::DEBUG;
impl From<Level> for u16 {
fn from(level: Level) -> u16 {
match level {
Level::SILENT => 0,
Level::FATAL => 1,
Level::ERROR => 2,
Level::WARN => 3,
Level::INFO => 4,
Level::DEBUG => 5,
Level::VERBOSE => 6,
Level::TRACE => 7,
Level::META => 37,
}
}
}
impl From<u16> for Level {
fn from(numeric: u16) -> Level {
if numeric == 0 {
Level::SILENT
} else if numeric == 1 {
Level::FATAL
} else if numeric == 2 {
Level::ERROR
} else if numeric == 3 {
Level::WARN
} else if numeric == 4 {
Level::INFO
} else if numeric == 5 {
Level::DEBUG
} else if numeric == 6 {
Level::VERBOSE
} else if numeric == 7 {
Level::TRACE
} else if numeric == 37 {
Level::META
} else {
super::ENV_DEFAULT
}
}
}
impl From<&str> for Level {
fn from(s: &str) -> Level {
if s == "0" || s.to_uppercase() == "SILENT" {
Level::SILENT
} else if s == "1" || s.to_uppercase() == "FATAL" {
Level::FATAL
} else if s == "2" || s.to_uppercase() == "ERROR" {
Level::ERROR
} else if s == "3"
|| s.to_uppercase() == "WARN"
|| s.to_uppercase() == "WARNING"
{
Level::WARN
} else if s == "4" || s.to_uppercase() == "INFO" {
Level::INFO
} else if s == "5" || s.to_uppercase() == "DEBUG" {
Level::DEBUG
} else if s == "6" || s.to_uppercase() == "VERBOSE" {
Level::VERBOSE
} else if s == "7" || s.to_uppercase() == "TRACE" {
Level::TRACE
} else if s == "37" || s.to_uppercase() == "META" {
Level::META
} else {
super::ENV_DEFAULT
}
}
}
impl std::fmt::Display for Level {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let s = match self {
Level::SILENT => "SILENT",
Level::FATAL => "FATAL",
Level::ERROR => "ERROR",
Level::WARN => "WARNING",
Level::INFO => "INFO",
Level::DEBUG => "DEBUG",
Level::VERBOSE => "VERBOSE",
Level::TRACE => "TRACE",
Level::META => "META",
};
write!(f, "{s}")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn u16_from_level() {
assert_eq!(u16::from(Level::SILENT), 0);
assert_eq!(u16::from(Level::FATAL), 1);
assert_eq!(u16::from(Level::ERROR), 2);
assert_eq!(u16::from(Level::WARN), 3);
assert_eq!(u16::from(Level::INFO), 4);
assert_eq!(u16::from(Level::DEBUG), 5);
assert_eq!(u16::from(Level::VERBOSE), 6);
assert_eq!(u16::from(Level::TRACE), 7);
assert_eq!(u16::from(Level::META), 37);
}
#[test]
fn level_from_u16() {
assert_eq!(Level::from(0), Level::SILENT);
assert_eq!(Level::from(1), Level::FATAL);
assert_eq!(Level::from(2), Level::ERROR);
assert_eq!(Level::from(3), Level::WARN);
assert_eq!(Level::from(4), Level::INFO);
assert_eq!(Level::from(5), Level::DEBUG);
assert_eq!(Level::from(6), Level::VERBOSE);
assert_eq!(Level::from(7), Level::TRACE);
assert_eq!(Level::from(37), Level::META);
assert_eq!(Level::from(99), Level::WARN);
}
#[test]
fn level_from_str() {
assert_eq!(Level::from("0"), Level::SILENT);
assert_eq!(Level::from("SILENT"), Level::SILENT);
assert_eq!(Level::from("silent"), Level::SILENT);
assert_eq!(Level::from("SiLEnT"), Level::SILENT);
assert_eq!(Level::from("1"), Level::FATAL);
assert_eq!(Level::from("FATAL"), Level::FATAL);
assert_eq!(Level::from("fatal"), Level::FATAL);
assert_eq!(Level::from("FaTaL"), Level::FATAL);
assert_eq!(Level::from("3"), Level::WARN);
assert_eq!(Level::from("WARN"), Level::WARN);
assert_eq!(Level::from("warn"), Level::WARN);
assert_eq!(Level::from("WaRn"), Level::WARN);
assert_eq!(Level::from("WARNING"), Level::WARN);
assert_eq!(Level::from("warning"), Level::WARN);
assert_eq!(Level::from("WaRninG"), Level::WARN);
assert_eq!(Level::from("4"), Level::INFO);
assert_eq!(Level::from("INFO"), Level::INFO);
assert_eq!(Level::from("info"), Level::INFO);
assert_eq!(Level::from("iNFo"), Level::INFO);
assert_eq!(Level::from("5"), Level::DEBUG);
assert_eq!(Level::from("DEBUG"), Level::DEBUG);
assert_eq!(Level::from("debug"), Level::DEBUG);
assert_eq!(Level::from("deBuG"), Level::DEBUG);
assert_eq!(Level::from("6"), Level::VERBOSE);
assert_eq!(Level::from("VERBOSE"), Level::VERBOSE);
assert_eq!(Level::from("verbose"), Level::VERBOSE);
assert_eq!(Level::from("VerBosE"), Level::VERBOSE);
assert_eq!(Level::from("7"), Level::TRACE);
assert_eq!(Level::from("TRACE"), Level::TRACE);
assert_eq!(Level::from("trace"), Level::TRACE);
assert_eq!(Level::from("trAcE"), Level::TRACE);
assert_eq!(Level::from("37"), Level::META);
assert_eq!(Level::from("META"), Level::META);
assert_eq!(Level::from("meta"), Level::META);
assert_eq!(Level::from("mETa"), Level::META);
}
#[test]
fn display_level() {
assert_eq!(format!("{}", Level::SILENT), "SILENT");
assert_eq!(format!("{}", Level::FATAL), "FATAL");
assert_eq!(format!("{}", Level::ERROR), "ERROR");
assert_eq!(format!("{}", Level::WARN), "WARNING");
assert_eq!(format!("{}", Level::INFO), "INFO");
assert_eq!(format!("{}", Level::DEBUG), "DEBUG");
assert_eq!(format!("{}", Level::VERBOSE), "VERBOSE");
assert_eq!(format!("{}", Level::TRACE), "TRACE");
assert_eq!(format!("{}", Level::META), "META");
}
}

211
src/dev/test.rs
View file

@ -1,211 +0,0 @@
use std::{env, fs, io, path::PathBuf};
use crate::prelude::*;
#[derive(Debug)]
pub struct Directories {
pub original: PathBuf,
pub templates: PathBuf,
pub assets: PathBuf,
pub test: PathBuf,
}
impl Directories {
/// Sets up self-cleaning original, temporary and 'templates' directories.
///
/// # Errors
/// May return Error when:
/// - Current directory does not exist or lacking permissions
/// - Several I/O possibilities from directory creation failures
/// - Several I/O possibilities from working directory changing failures
pub fn setup(dir_name: &str) -> Result<Directories, Error> {
let original = env::current_dir()?;
let test = original.join(format!("target/mocks/{dir_name}"));
let templates = test.join("templates");
let assets = test.join("static").join("public").join("assets");
drop(fs::remove_dir_all(&test));
if let Err(error) = fs::create_dir_all(&test) {
return Err(Error::with_io(
"Failed test's directory creation",
error,
))
}
if let Err(error) = fs::create_dir_all(&templates) {
return Err(Error::with_io(
"Failed 'templates' directory creation",
error,
))
}
if let Err(error) = fs::create_dir_all(&assets) {
return Err(Error::with_io(
"Failed 'assets' directory creation",
error,
))
}
if let Err(error) = env::set_current_dir(&test) {
return Err(Error::with_io("Failed current directory change", error))
}
Ok(Directories {
original,
templates,
assets,
test,
})
}
}
impl Drop for Directories {
fn drop(&mut self) {
if let Err(error) = std::env::set_current_dir(&self.original) {
log!(ERROR, "Couldn't reset to original directory: {error}");
}
if let Err(error) = std::fs::remove_dir_all(&self.test) {
log!(WARN, "Couldn't cleanup test directory: {error}");
}
}
}
#[derive(Debug)]
pub struct Error {
pub message: String,
pub inner_io: Option<io::Error>,
pub inner_tera: Option<tera::Error>,
}
impl Error {
fn with_io(message: &str, inner_error: io::Error) -> Error {
Error {
message: String::from(message),
inner_io: Some(inner_error),
inner_tera: None,
}
}
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let mut message = self.message.clone();
if let Some(inner_io) = &self.inner_io {
message = format!("{message}\n{inner_io}");
}
if let Some(inner_tera) = &self.inner_tera {
message = format!("{message}\n{inner_tera}");
}
write!(f, "{message}")
}
}
impl From<String> for Error {
fn from(string: String) -> Error {
Error {
message: string,
inner_io: None,
inner_tera: None,
}
}
}
impl From<&str> for Error {
fn from(str: &str) -> Error { Error::from(String::from(str)) }
}
impl From<io::Error> for Error {
fn from(inner: io::Error) -> Error {
let mut error = Error::from(inner.to_string());
error.inner_io = Some(inner);
error
}
}
impl From<tera::Error> for Error {
fn from(inner: tera::Error) -> Error {
let mut error = Error::from(inner.to_string());
error.inner_tera = Some(inner);
error
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bad_test_directory_name() {
let dirs = Directories::setup("\0");
assert!(dirs.is_err());
}
#[test]
fn display_contains_str_from_from() {
let payload = "rHneusPkYNGW0Ia0";
let error = Error::from(payload);
assert!(format!("{error}").contains(payload));
}
#[test]
fn display_contains_str_from_io_error() {
let payload = "SsVi0d3Ywc8kVhwp";
let io_payload = "LoPbZP7cJEHzAjGW";
let io_error = std::io::Error::other(io_payload);
let error = Error::with_io(payload, io_error);
assert!(format!("{error}").contains(payload));
assert!(format!("{error}").contains(io_payload));
}
#[test]
fn display_contains_str_from_tera_error() {
let payload = "pA6B0LhiiDMNCl1J";
let tera_payload = "5ob8H594dCAQ8pfk";
let error = Error {
message: payload.to_string(),
inner_tera: Some(tera::Error::msg(tera_payload)),
inner_io: None,
};
assert!(format!("{error}").contains(payload));
assert!(format!("{error}").contains(tera_payload));
}
#[test]
fn from_io_error() {
let payload = "YgmTKBm3VtHt5h3x9";
let io_error = std::io::Error::other(payload);
let error = Error::from(io_error);
assert!(error.message.contains(payload));
}
#[test]
fn from_tera_error() {
let payload = "XEB3dcvYuz0M1lYt";
let tera_error = tera::Error::msg(payload);
let error = Error::from(tera_error);
assert!(error.message.contains(payload));
}
}
#[cfg(test)]
mod serial_tests {
use super::*;
#[test]
fn failed_working_directory_reset() {
let dirs = Directories::setup("\0");
let error = dirs.unwrap_err();
println!("{error}");
assert!(error.message.contains("Failed test's directory creation"));
assert!(
format!("{error}")
.contains("file name contained an unexpected NUL byte")
);
}
}

986
src/graph.rs
View file

File diff suppressed because it is too large Load diff

3
src/graph/edge.rs
View file

@ -1,8 +1,7 @@
use serde::{Deserialize, Serialize};
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize, Clone, Default, PartialEq, Eq, Debug)]
pub struct Edge {
#[serde(default)]
pub to: String,
#[serde(default)]
pub from: String,

481
src/graph/meta.rs
View file

@ -1,12 +1,10 @@
use serde::{Deserialize, Serialize};
use crate::prelude::*;
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct Meta {
pub config: Config,
#[serde(default)]
pub version: Version,
pub version: Option<Version>,
#[serde(default)]
pub messages: Vec<String>,
#[serde(default)]
@ -17,7 +15,7 @@ impl Default for Meta {
fn default() -> Meta {
Meta {
config: Config::default(),
version: Version::from_compilation().unwrap_or_default(),
version: Version::from_env(),
messages: vec![],
malformed: false,
}
@ -44,8 +42,6 @@ pub struct Config {
pub footer_credits: bool,
#[serde(default = "mktrue")]
pub footer_date: bool,
#[serde(default = "mktrue")]
pub footer_version: bool,
#[serde(default)]
pub footer_text: String,
#[serde(default = "mk8")]
@ -66,8 +62,6 @@ pub struct Config {
pub raw_json: bool,
#[serde(default = "mktrue")]
pub raw_toml: bool,
#[serde(default = "mktrue")]
pub serve_fonts: bool,
#[serde(default)]
pub site_description: String,
#[serde(default)]
@ -90,7 +84,6 @@ impl Default for Config {
footer: true,
footer_credits: true,
footer_date: true,
footer_version: true,
footer_text: String::default(),
index_node_count: 8,
index_node_list: true,
@ -101,7 +94,6 @@ impl Default for Config {
raw: true,
raw_json: true,
raw_toml: true,
serve_fonts: true,
site_description: String::default(),
site_title: String::default(),
tree: true,
@ -111,235 +103,22 @@ impl Default for Config {
}
// See: https://github.com/serde-rs/serde/issues/368
const fn mktrue() -> bool { true }
const fn mkfalse() -> bool { false }
const fn mk8() -> u16 { 8 }
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct Version {
major: u8,
minor: u8,
patch: u8,
qualifier: Option<String>,
fn mktrue() -> bool {
true
}
impl Default for Version {
fn default() -> Version {
match Version::from_compilation() {
Ok(v) => v,
Err(e) => {
log!(ERROR, "{e}");
Version {
major: 0,
minor: 0,
patch: 0,
qualifier: None,
}
},
}
}
fn mkfalse() -> bool {
false
}
impl std::fmt::Display for Version {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
if let Some(qualifier) = &self.qualifier {
write!(
f,
"{}.{}.{}-{qualifier}",
self.major, self.minor, self.patch
)
} else {
write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
}
}
}
impl Version {
/// Parses the compile-time version into a Version struct.
///
/// # Errors
/// This function is a thin wrapper around `Meta::from_text` and will
/// return its errors without change.
pub fn from_compilation() -> Result<Version, VersionError> {
Version::from_text(env!("CARGO_PKG_VERSION"))
}
/// Parses a string into a Version struct.
///
/// It is expected for the version string to contain exactly three
/// dot-separated numeric values with an optional leading `v` character.
///
/// # Errors
/// Will error if the version string is malformed.
pub fn from_text(version: &str) -> Result<Version, VersionError> {
use VersionErrorCause::*;
let triple: Vec<String> =
version.split('.').map(str::to_string).collect();
let has_two_dots = version.matches('.').count() == 2;
let has_three_elements = triple.len() == 3;
let has_whitespace = version.contains(' ') || version.contains('\n');
let has_contiguous_dots = version.contains("..");
let ends_with_dot = version.ends_with('.');
let starts_with_dot = version.starts_with('.');
let major: u8 = if let Some(s) = triple.first()
&& !s.is_empty()
{
match s.trim_start_matches('v').trim().parse() {
Ok(parsed) => parsed,
Err(e) => {
return Err(VersionError {
cause: FailedMajorParse,
message: Some(e.to_string()),
});
},
}
} else {
return Err(VersionError {
cause: MissingMajor,
message: None,
});
};
let minor: u8 = if triple.len() >= 2
&& let Some(s) = triple.get(1)
{
match s.trim().parse() {
Ok(parsed) => parsed,
Err(e) => {
return Err(VersionError {
cause: FailedMinorParse,
message: Some(e.to_string()),
});
},
}
} else {
return Err(VersionError {
cause: MissingMinor,
message: None,
});
};
let patch: u8 = if triple.len() >= 3
&& let Some(s) = triple.get(2)
{
let patch_number = if let Some(split) = s.split_once('-') {
split.0
} else {
s
};
match patch_number.trim().parse() {
Ok(parsed) => parsed,
Err(e) => {
return Err(VersionError {
cause: FailedPatchParse,
message: Some(e.to_string()),
});
},
}
} else {
return Err(VersionError {
cause: MissingPatch,
message: None,
});
};
let qualifier: Option<String> = if let Some(tail) = triple.get(2) {
tail.split_once('-').map(|split| String::from(split.1))
} else {
None
};
let conditions = has_two_dots
&& has_three_elements
&& !has_whitespace
&& !has_contiguous_dots
&& !ends_with_dot
&& !starts_with_dot;
if conditions {
Ok(Version {
major,
minor,
patch,
qualifier,
})
} else {
Err(VersionError {
cause: FailedValidation,
message: Some(format!(
"Evaluated rules (all must be true):\n\
Has exactly two dots: {has_two_dots},\n\
Splits to three elements: {has_three_elements}\n\
Has no whitespace: {}\n\
Has no contiguous dots: {}\n\
Does not end with a dot: {}\n\
Does not start with a dot: {}",
!has_whitespace,
!has_contiguous_dots,
!ends_with_dot,
!starts_with_dot,
)),
})
}
}
}
#[derive(Debug)]
pub struct VersionError {
cause: VersionErrorCause,
message: Option<String>,
}
#[derive(Debug)]
enum VersionErrorCause {
MissingMajor,
FailedMajorParse,
MissingMinor,
FailedMinorParse,
MissingPatch,
FailedPatchParse,
FailedValidation,
}
impl std::fmt::Display for VersionError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
if let Some(message) = &self.message {
write!(f, "{}: {}", self.cause, message)
} else {
write!(f, "{}", self.cause)
}
}
}
impl std::fmt::Display for VersionErrorCause {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
use VersionErrorCause as V;
write!(
f,
"{}",
match self {
V::MissingMajor => "Major version couldn't be split",
V::FailedMajorParse => "Failed parse of major version",
V::MissingMinor => "Minor version couldn't be split",
V::FailedMinorParse => "Failed parse of minor version",
V::MissingPatch => "Patch version couldn't be split",
V::FailedPatchParse => "Failed parse of patch version",
V::FailedValidation => "Validation failed",
}
)
}
fn mk8() -> u16 {
8
}
#[cfg(test)]
mod tests {
use super::*;
use crate::graph::Graph;
use super::*;
#[test]
fn empty_footer_text() {
let mut graph = Graph::load();
@ -400,208 +179,60 @@ mod tests {
== 1
);
}
}
#[test]
fn modulated_graph_version_matches_compilation_version() {
let version = Graph::load().meta.version;
#[derive(Serialize, Deserialize, Clone, Default, PartialEq, Eq, Debug)]
pub struct Version {
major: u8,
minor: u8,
patch: u8,
}
assert_eq!(format!("{version}"), env!("CARGO_PKG_VERSION"));
impl Version {
pub fn from_env() -> Option<Version> {
Version::from(env!("CARGO_PKG_VERSION"))
}
#[test]
fn from_compilation_matches_compilation_version() {
let version = Version::from_compilation().unwrap();
pub fn from(version: &str) -> Option<Version> {
let triple: Vec<String> =
version.split('.').map(str::to_string).collect();
assert_eq!(format!("{version}"), env!("CARGO_PKG_VERSION"));
}
let has_two_dots = version.matches('.').count() == 2;
let has_three_elements = triple.len() == 3;
let has_whitespace = version.contains(' ') || version.contains('\n');
let has_contiguous_dots = version.contains("..");
let ends_with_dot = version.ends_with('.');
let starts_with_dot = version.starts_with('.');
#[test]
fn version_from_str() {
let payload = "3.9.74";
let version_result = Version::from_text(payload);
let major: u8 = if let Some(s) = triple.first() {
s.trim_start_matches('v').trim().parse().ok()?
} else {
return None;
};
println!("{version_result:#?}");
assert_eq!(format!("{}", version_result.unwrap()), payload);
}
let minor: u8 = if let Some(s) = triple.get(1) {
s.trim().parse().ok()?
} else {
return None;
};
#[test]
fn missing_major() {
let error = Version::from_text("").unwrap_err();
println!("{error:#?}");
assert!(matches!(error.cause, VersionErrorCause::MissingMajor));
}
let patch: u8 = if let Some(s) = triple.get(2) {
s.trim().parse().ok()?
} else {
return None;
};
#[test]
fn missing_minor() {
let error = Version::from_text("3").unwrap_err();
println!("{error:#?}");
assert!(matches!(error.cause, VersionErrorCause::MissingMinor));
}
let conditions = has_two_dots
&& has_three_elements
&& !has_whitespace
&& !has_contiguous_dots
&& !ends_with_dot
&& !starts_with_dot;
#[test]
fn missing_patch() {
let error = Version::from_text("3.6").unwrap_err();
assert!(matches!(error.cause, VersionErrorCause::MissingPatch));
}
#[test]
fn malformed_patch() {
let error = Version::from_text("3.6.x").unwrap_err();
assert!(matches!(error.cause, VersionErrorCause::FailedPatchParse));
let error_empty = Version::from_text("3.6.").unwrap_err();
assert!(matches!(
error_empty.cause,
VersionErrorCause::FailedPatchParse
));
}
#[test]
fn malformed_minor() {
let error = Version::from_text("3.x.0").unwrap_err();
assert!(matches!(error.cause, VersionErrorCause::FailedMinorParse));
let error_bad_patch = Version::from_text("3.x.z").unwrap_err();
assert!(matches!(
error_bad_patch.cause,
VersionErrorCause::FailedMinorParse
));
let error_empty_patch = Version::from_text("3.x.").unwrap_err();
assert!(matches!(
error_empty_patch.cause,
VersionErrorCause::FailedMinorParse
));
let error_patchless = Version::from_text("3.x").unwrap_err();
assert!(matches!(
error_patchless.cause,
VersionErrorCause::FailedMinorParse
));
let error_empty = Version::from_text("3.").unwrap_err();
assert!(matches!(
error_empty.cause,
VersionErrorCause::FailedMinorParse
));
}
#[test]
fn malformed_major() {
let error = Version::from_text("x.6.0").unwrap_err();
assert!(matches!(error.cause, VersionErrorCause::FailedMajorParse));
let error_bad_patch = Version::from_text("x.y.z").unwrap_err();
assert!(matches!(
error_bad_patch.cause,
VersionErrorCause::FailedMajorParse
));
let error_empty_patch = Version::from_text("x.6.").unwrap_err();
assert!(matches!(
error_empty_patch.cause,
VersionErrorCause::FailedMajorParse
));
let error_patchless = Version::from_text("x.6").unwrap_err();
assert!(matches!(
error_patchless.cause,
VersionErrorCause::FailedMajorParse
));
let error_bad_minor = Version::from_text("x.y").unwrap_err();
assert!(matches!(
error_bad_minor.cause,
VersionErrorCause::FailedMajorParse
));
let error_empty_minor = Version::from_text("x.").unwrap_err();
assert!(matches!(
error_empty_minor.cause,
VersionErrorCause::FailedMajorParse
));
let error_minorless = Version::from_text("x").unwrap_err();
assert!(matches!(
error_minorless.cause,
VersionErrorCause::FailedMajorParse
));
let error_empty = Version::from_text("").unwrap_err();
assert!(matches!(error_empty.cause, VersionErrorCause::MissingMajor));
}
#[test]
fn version_validation() {
assert!(["3.1.4.", "3.1.4.1"].iter().all(|s| matches!(
Version::from_text(s).unwrap_err().cause,
VersionErrorCause::FailedValidation
)));
}
#[test]
fn leading_v() {
let version = Version::from_text("v3.1.4").unwrap();
assert_eq!(format!("{version}"), "3.1.4");
}
#[test]
fn display_version_error_cause() {
fn assert(version: &str, message: &str) {
let error = Version::from_text(version).unwrap_err();
assert_eq!(format!("{error}"), message);
}
assert("3.6", "Patch version couldn't be split");
assert(
"3.6.",
"Failed parse of patch version: \
cannot parse integer from empty string",
);
assert(
"3.6.x",
"Failed parse of patch version: \
invalid digit found in string",
);
assert("3", "Minor version couldn't be split");
assert(
"3.",
"Failed parse of minor version: \
cannot parse integer from empty string",
);
assert(
"3.x",
"Failed parse of minor version: \
invalid digit found in string",
);
assert("", "Major version couldn't be split");
assert(
"x",
"Failed parse of major version: \
invalid digit found in string",
);
let validation_error = Version::from_text("3.1.4.1..").unwrap_err();
println!("{validation_error}");
assert!(matches!(
validation_error.cause,
VersionErrorCause::FailedValidation
));
assert!(
validation_error
.message
.clone()
.unwrap()
.contains("Has exactly two dots: false")
);
assert!(
validation_error
.message
.unwrap()
.contains("Splits to three elements: false")
);
conditions.then_some(Version {
major,
minor,
patch,
})
}
}

127
src/graph/node.rs
View file

@ -1,6 +1,6 @@
use std::collections::HashMap;
use serde::{Deserialize, Serialize};
use serde::{Serialize, Deserialize};
use super::edge::Edge;
@ -18,19 +18,16 @@ pub struct Node {
pub links: Vec<String>,
#[serde(default)]
pub redirect: String,
#[serde(default = "mktrue")]
pub listed: bool,
#[serde(default)]
pub connections: HashMap<String, Edge>,
pub hidden: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub connections: Option<HashMap<String, Edge>>,
#[serde(default)]
pub stats: Stats,
}
// See: https://github.com/serde-rs/serde/issues/368
const fn mktrue() -> bool { true }
#[derive(Serialize, Deserialize, Clone, Default, Eq, PartialEq, Debug)]
pub struct Stats {
pub outgoing: u32,
@ -38,7 +35,7 @@ pub struct Stats {
}
impl Node {
pub fn not_found(message: Option<String>) -> Node {
pub fn new(message: Option<String>) -> Node {
Node {
id: "404".to_string(),
title: "Not Found".to_string(),
@ -46,10 +43,10 @@ impl Node {
Some(s) => s,
None => "Node not found.".to_string(),
},
connections: HashMap::default(),
connections: None,
links: vec![],
redirect: String::default(),
listed: true,
hidden: false,
summary: String::default(),
stats: Stats::default(),
}
@ -58,36 +55,35 @@ impl Node {
impl std::fmt::Display for Node {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let mut meta_elements: Vec<String> = vec![];
if !self.title.is_empty() {
meta_elements.push(format!("title:'{}'", self.title));
let mut meta = String::default();
if self.title.is_empty() {
meta.push_str("title:none");
} else {
meta.push_str(&format!("title:'{}'", self.title));
}
if !self.text.is_empty() {
meta_elements.push(format!("text:{}l", self.text.len()));
if self.text.is_empty() {
meta.push_str(" text:none");
} else {
meta.push_str(&format!(" text:{}l", self.text.len()));
}
if !self.summary.is_empty() {
meta_elements.push(format!("summary:{}", self.summary.len()));
if self.summary.is_empty() {
meta.push_str(" summary:none");
} else {
meta.push_str(&format!(" summary:{}", self.summary.len()));
}
if !self.redirect.is_empty() {
meta_elements.push(format!("redirect:{}", self.redirect));
if self.redirect.is_empty() {
meta.push_str(" redirect:none");
} else {
meta.push_str(&format!(" redirect:{}", self.redirect));
}
let links = self.links.len();
if links > 0 {
meta_elements.push(format!("links:{links}"));
meta.push_str(&format!(" links:{links}"));
}
if !self.listed {
meta_elements.push(String::from("unlisted"));
if self.hidden {
meta.push_str(" hidden");
}
let meta = meta_elements.join(" ");
write!(f, "Node {} [{meta}]", self.id)
write!(f, "Node: ID '{}' {meta}", self.id)
}
}
@ -97,70 +93,7 @@ mod tests {
#[test]
fn empty_node_message() {
let node = Node::not_found(None);
let node = Node::new(None);
assert_eq!(node.text, "Node not found.");
}
#[test]
fn display() {
let mut node = Node::not_found(None);
assert_eq!(format!("{node}"), "Node 404 [title:'Not Found' text:15l]");
let summary = "X2hSwanDoLdqLZNnYJagcWKFJVAx5TGF";
node.summary = String::from(summary);
assert_eq!(
format!("{node}"),
format!(
"Node 404 [title:'Not Found' text:15l summary:{}]",
summary.len()
)
);
let redirect = "ukfF3kz130oUzT2ushBIvEHx8xoY8ke0";
node.redirect = String::from(redirect);
assert_eq!(
format!("{node}"),
format!(
"Node 404 [title:'Not Found' \
text:15l summary:{} \
redirect:{redirect}]",
summary.len(),
)
);
node.links.push(String::from("1"));
node.links.push(String::from("2"));
node.links.push(String::from("3"));
assert_eq!(
format!("{node}"),
format!(
"Node 404 [\
title:'Not Found' \
text:15l summary:{} \
redirect:{redirect} \
links:{}\
]",
summary.len(),
node.links.len(),
)
);
node.listed = false;
assert_eq!(
format!("{node}"),
format!(
"Node 404 [\
title:'Not Found' \
text:15l summary:{} \
redirect:{redirect} \
links:{} \
unlisted\
]",
summary.len(),
node.links.len(),
)
);
}
}

10
src/lib.rs
View file

@ -1,16 +1,16 @@
use std::{sync, time};
pub mod prelude {
pub use crate::{
dev::log::{Level::*, now},
log, tlog, write_log,
};
pub use crate::log;
pub use crate::tlog;
pub use crate::log::Level::*;
pub use crate::log::now;
}
pub mod dev;
pub mod graph;
pub mod router;
pub mod syntax;
pub mod log;
pub static ONSET: sync::LazyLock<time::Instant> =
sync::LazyLock::new(time::Instant::now);

49
src/dev/log.rs → src/log.rs
View file

@ -4,7 +4,7 @@ pub use level::*;
mod level;
/// Strings in this slice suppress logging if found in the stack trace.
/// Strings in this slice suppress logging if found in the stack trace
pub const EXCLUSIONS: &[&str] = &["en::graph::Graph::parse_config"];
#[derive(Debug)]
@ -32,7 +32,7 @@ impl Data {
let path = make_display_path(captured_path, &env_level);
let is_silent = env_level <= Level::SILENT;
let level_within_env_level = message_level <= env_level;
let message_level_is_within_env_level = message_level <= env_level;
let excluded_in_code =
!EXCLUSIONS.iter().all(|&s| !trace_string.contains(s));
let excluded_by_env =
@ -41,17 +41,17 @@ impl Data {
filter.is_empty() || captured_path.contains(&filter);
let should_log = !is_silent
&& level_within_env_level
&& message_level_is_within_env_level
&& !excluded_in_code
&& !excluded_by_env
&& matches_filter;
#[expect(clippy::print_stderr)]
#[allow(clippy::print_stderr)]
if env_level == Level::META {
eprintln!(
"Log decision for message from {path}: {should_log} given\n\
is_silent: {is_silent} (expected false)\n\
level_within_env_level: {level_within_env_level}\n\
message_level_is_within_env_level: {message_level_is_within_env_level}\n\
excluded_in_code: {excluded_in_code} (expected false)\n\
excluded_by_env: {excluded_by_env} (expected false)\n\
matches_filter: {matches_filter}\n\
@ -79,7 +79,7 @@ pub fn env_level() -> Level {
}
}
#[expect(clippy::print_stderr)]
#[allow(clippy::print_stderr)]
pub fn print_state() {
let env_level = env_level();
let version = env!("CARGO_PKG_VERSION");
@ -90,7 +90,7 @@ pub fn print_state() {
}
}
#[expect(clippy::print_stderr)]
#[allow(clippy::print_stderr)]
pub fn timed(past: &Instant, message: &str) -> Instant {
let now = Instant::now();
let env_level = env_level();
@ -114,13 +114,15 @@ pub fn timed(past: &Instant, message: &str) -> Instant {
#[macro_export]
macro_rules! tlog {
($instant:expr, $fmt:expr $(, $($arg:tt)+ )?) => {{
$crate::dev::log::timed($instant, &format!($fmt $(, $($arg)+ )?))
$crate::log::timed($instant, &format!($fmt $(, $($arg)+ )?))
}};
}
pub fn now() -> Instant { Instant::now() }
pub fn now() -> Instant {
Instant::now()
}
#[expect(clippy::print_stderr, clippy::use_debug)]
#[allow(clippy::print_stderr)]
pub fn elog(function: &str, message: &str) {
eprintln!("{:?} [{function}] {message}", crate::ONSET.elapsed());
}
@ -129,26 +131,26 @@ pub fn elog(function: &str, message: &str) {
macro_rules! log {
($level:path, $fmt:expr $(, $($arg:tt)+ )?) => {{
let data = $crate::dev::log::Data::new(
let data = $crate::log::Data::new(
Some($level),
std::any::type_name_of_val(&|| {}),
std::backtrace::Backtrace::capture(),
);
if data.should_log {
$crate::dev::log::elog(&data.path, &format!($fmt $(, $($arg)+ )?));
$crate::log::elog(&data.path, &format!($fmt $(, $($arg)+ )?));
}
}};
($fmt:expr $(, $($arg:tt)+ )?) => {{
let data = $crate::dev::log::Data::new(
let data = $crate::log::Data::new(
None,
std::any::type_name_of_val(&|| {}),
std::backtrace::Backtrace::capture(),
);
if data.should_log {
$crate::dev::log::elog(&data.path, &format!($fmt $(, $($arg)+ )?));
$crate::log::elog(&data.path, &format!($fmt $(, $($arg)+ )?));
};
}};
@ -209,22 +211,13 @@ pub fn wrap(s: &str) -> String {
}
}
fn escape(s: &str) -> String { s.escape_debug().collect() }
fn escape(s: &str) -> String {
s.escape_debug().collect()
}
symbolize(&quote(&escape(s)))
}
#[macro_export]
macro_rules! write_log {
($buffer:expr, $format_string:expr $(, $format_args:expr)* $(,)?) => {{
use std::fmt::Write as _;
let result = write!($buffer, $format_string $(, $format_args)*);
if let Err(error) = result {
log!(ERROR, "Unexpected error writing into {}: ${error}", $buffer);
}
}};
}
#[cfg(test)]
mod tests {
use super::*;
@ -250,7 +243,7 @@ mod tests {
}
fn run_in_debug_level(level: &str) {
#[expect(unsafe_code)]
#[allow(unsafe_code)]
unsafe {
std::env::set_var("DEBUG", level);
log!("Debug is set to {level}");
@ -272,7 +265,7 @@ mod tests {
fn test(&self);
}
struct Logger;
struct Logger {}
impl Loggable for Logger {
fn test(&self) {

105
src/log/level.rs Normal file
View file

@ -0,0 +1,105 @@
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
#[repr(u16)]
pub enum Level {
SILENT = 0,
FATAL = 1,
ERROR = 2,
WARN = 3,
INFO = 4,
DEBUG = 5,
VERBOSE = 6,
TRACE = 7,
META = 37,
}
pub const ENV_DEFAULT: Level = Level::WARN;
pub const MESSAGE_DEFAULT: Level = Level::DEBUG;
impl From<Level> for u16 {
fn from(level: Level) -> u16 {
match level {
Level::SILENT => 0,
Level::FATAL => 1,
Level::ERROR => 2,
Level::WARN => 3,
Level::INFO => 4,
Level::DEBUG => 5,
Level::VERBOSE => 6,
Level::TRACE => 7,
Level::META => 37,
}
}
}
impl From<u16> for Level {
fn from(numeric: u16) -> Level {
if numeric == 0 {
Level::SILENT
} else if numeric == 1 {
Level::FATAL
} else if numeric == 2 {
Level::ERROR
} else if numeric == 3 {
Level::WARN
} else if numeric == 4 {
Level::INFO
} else if numeric == 5 {
Level::DEBUG
} else if numeric == 6 {
Level::VERBOSE
} else if numeric == 7 {
Level::TRACE
} else if numeric == 37 {
Level::META
} else {
super::ENV_DEFAULT
}
}
}
impl From<&str> for Level {
fn from(s: &str) -> Level {
if s == "0" || s == "SILENT" || s == "silent" {
Level::SILENT
} else if s == "1" || s == "FATAL" || s == "fatal" {
Level::FATAL
} else if s == "2" || s == "ERROR" || s == "error" {
Level::ERROR
} else if s == "3"
|| s == "WARN"
|| s == "warn"
|| s == "WARNING"
|| s == "warning"
{
Level::WARN
} else if s == "4" || s == "INFO" || s == "info" {
Level::INFO
} else if s == "5" || s == "DEBUG" || s == "debug" {
Level::DEBUG
} else if s == "6" || s == "VERBOSE" || s == "verbose" {
Level::VERBOSE
} else if s == "7" || s == "TRACE" || s == "trace" {
Level::TRACE
} else if s == "37" || s == "META" || s == "meta" {
Level::META
} else {
super::ENV_DEFAULT
}
}
}
impl std::fmt::Display for Level {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let s = match self {
Level::SILENT => "SILENT",
Level::FATAL => "FATAL",
Level::ERROR => "ERROR",
Level::WARN => "WARNING",
Level::INFO => "INFO",
Level::DEBUG => "DEBUG",
Level::VERBOSE => "VERBOSE",
Level::TRACE => "TRACE",
Level::META => "META",
};
write!(f, "{s}")
}
}

20
src/main.rs
View file

@ -1,12 +1,17 @@
use std::{backtrace, io, panic};
use en::{ONSET, dev::log, graph::Graph, prelude::*, syntax};
use en::{ONSET, graph::Graph, log, prelude::*, syntax};
#[tokio::main]
#[expect(clippy::print_stderr, clippy::print_stdout, clippy::use_debug)]
#[allow(clippy::print_stderr, clippy::print_stdout)]
async fn main() -> io::Result<()> {
log::print_state();
let mut instant = now();
let args = syntax::command::Arguments::default().parse();
let address = args.make_address();
instant = tlog!(&instant, "Parsed CLI arguments");
panic::set_hook(Box::new(|info| {
let payload = info
.payload_as_str()
@ -32,23 +37,12 @@ async fn main() -> io::Result<()> {
}));
instant = tlog!(&instant, "Set up panic hook");
let args = syntax::command::Arguments::default().parse();
instant = tlog!(&instant, "Parsed CLI arguments");
if args.flags.version {
println!(env!("CARGO_PKG_VERSION"));
return Ok(());
}
log::print_state();
let graph = Graph::load();
instant = tlog!(&instant, "Loaded graph");
let router = en::router::new(graph);
tlog!(&instant, "Initialized router");
let address = args.make_address();
let listener =
tokio::net::TcpListener::bind(&address).await.map_err(|e| {
log!(ERROR, "Failed to create listener at {address}: {e:#?}");

21
src/router.rs
View file

@ -3,13 +3,13 @@ use axum::{Router, routing::get};
use crate::graph::Graph;
mod handlers {
pub mod error;
pub mod fixed;
pub mod graph;
pub mod mime;
pub mod navigation;
pub mod raw;
pub mod template;
pub mod raw;
pub mod navigation;
pub mod fixed;
pub mod error;
pub mod mime;
}
#[derive(Clone)]
@ -33,8 +33,7 @@ pub fn new(graph: Graph) -> Router {
.route("/graph/{format}", get(handlers::fixed::serial))
.route("/search", get(handlers::navigation::search))
.route("/redirect", get(handlers::navigation::redirect))
.route("/static/{*path}", get(handlers::fixed::file))
.route("/legal", get(handlers::navigation::legal));
.route("/static/{*path}", get(handlers::fixed::file));
if state.graph.meta.config.tree {
router = router.route("/tree", get(handlers::navigation::tree));
@ -50,6 +49,11 @@ pub fn new(graph: Graph) -> Router {
#[cfg(test)]
mod tests {
use crate::{
graph::{Graph, Config, Meta},
};
use super::*;
use axum::{
body::Body,
http::{Request, StatusCode},
@ -57,9 +61,6 @@ mod tests {
};
use tower::ServiceExt as _;
use super::*;
use crate::graph::{Config, Graph, Meta};
async fn request(uri: &str, config: Option<&Config>) -> Response<Body> {
let default_graph = Graph::load();
let graph = Graph {

26
src/router/handlers/error.rs
View file

@ -9,7 +9,7 @@ use crate::{
router::{GlobalState, handlers},
};
pub(in crate::router::handlers) fn make(
pub(in crate::router::handlers) fn by_code(
code: Option<u16>,
message: Option<&str>,
graph: &Graph,
@ -47,21 +47,19 @@ fn make_body(
context.insert("message", out_message);
context.insert("status_code", &out_code.to_string());
match handlers::template::render(
handlers::template::render(
"error",
&context,
Some(&format!(
"Failed to render template for Error {out_code}: {out_message}"
))
.cloned(),
) {
Ok(rendered) => rendered.html,
Err(error) => error.template.html,
}
)
.0
}
pub async fn not_found(State(state): State<GlobalState>) -> Response<Body> {
make(
by_code(
Some(404),
Some("The page you tried to access could not be found."),
&state.graph,
@ -70,8 +68,10 @@ pub async fn not_found(State(state): State<GlobalState>) -> Response<Body> {
#[cfg(test)]
mod tests {
use axum::{extract::State, http::StatusCode};
use axum::{
http::{StatusCode},
extract::State,
};
use super::*;
#[tokio::test]
@ -86,10 +86,10 @@ mod tests {
#[tokio::test]
async fn internal_error() {
let graph = Graph::load();
assert!(make(Some(201), None, &graph).status() == 201);
assert!(make(Some(304), None, &graph).status() == 304);
assert!(make(Some(418), None, &graph).status() == 418);
assert!(make(Some(505), None, &graph).status() == 505);
assert!(by_code(Some(201), None, &graph).status() == 201);
assert!(by_code(Some(304), None, &graph).status() == 304);
assert!(by_code(Some(418), None, &graph).status() == 418);
assert!(by_code(Some(505), None, &graph).status() == 505);
}
#[test]

790
src/router/handlers/fixed.rs
View file

@ -1,311 +1,66 @@
use std::{collections::HashMap, io::ErrorKind, string::FromUtf8Error};
use axum::{
http::{HeaderValue, Response, StatusCode, header},
{
body::Body,
extract::{Path, State},
http::{HeaderValue, Response, header},
},
};
use serde::Serialize;
use crate::prelude::*;
use crate::{
dev::log,
graph::{Format, Graph, SerialErrorCause},
prelude::*,
router::{
GlobalState,
handlers::{self, error, mime},
},
router::{GlobalState, handlers},
router::handlers::mime::Mime,
};
/// Assembles an HTTP response given Asset.
fn assemble(asset: Asset, graph: &Graph) -> Response<Body> {
let set_content_type = |response: &mut Response<_>, content_type: &str| {
if let Ok(header_value) =
HeaderValue::from_str(&String::from(content_type))
{
response
.headers_mut()
.append(header::CONTENT_TYPE, header_value);
} else {
// This should be unreachable considering the possible mimetypes
// and their string representations are internal to en
log!(
WARN,
"Failed to create content type header value from {content_type}"
);
}
};
match asset.mime.kind() {
mime::Kind::Text => {
if let Some(text) = asset.text {
let mut response = Response::new(Body::from(text));
set_content_type(
&mut response,
&String::from(asset.mime.clone()),
);
response
} else {
// This should be unreachable, considering the constructors
// will convert to text even if a blob is passed
let mut response = error::make(
Some(500),
Some(
"Asset mimetype indicates text content, \
but none was found",
),
graph,
);
set_content_type(&mut response, "text/html");
response
}
},
mime::Kind::Font | mime::Kind::Blob | mime::Kind::Image => {
if let Some(blob) = asset.blob {
let mut response = Response::new(Body::from(blob));
set_content_type(
&mut response,
&String::from(asset.mime.clone()),
);
response
} else {
// This should be unreachable, considering the constructors
// will convert to blob even if a text is passed
let mut response = error::make(
Some(500),
Some(
"Asset mimetype indicates binary content, \
but none was found",
),
graph,
);
set_content_type(&mut response, "text/html");
response
}
},
}
}
#[derive(Debug)]
#[expect(clippy::upper_case_acronyms)]
pub enum AssetErrorKind {
NotFound,
IO,
UTF8,
Unknown,
}
#[derive(Debug)]
pub struct AssetError {
pub path: String,
pub kind: AssetErrorKind,
pub io_error: Option<std::io::Error>,
pub utf8_error: Option<FromUtf8Error>,
}
impl AssetError {
fn new(
path: &str,
kind: AssetErrorKind,
io_error: Option<std::io::Error>,
utf8_error: Option<FromUtf8Error>,
) -> AssetError {
AssetError {
path: String::from(path),
kind,
io_error,
utf8_error,
}
}
}
impl From<FromUtf8Error> for AssetError {
fn from(error: FromUtf8Error) -> AssetError {
AssetError::new("", AssetErrorKind::UTF8, None, Some(error))
}
}
impl From<String> for AssetError {
fn from(string: String) -> AssetError {
AssetError::new(&string, AssetErrorKind::Unknown, None, None)
}
}
impl std::fmt::Display for AssetError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let mut message = match self.kind {
AssetErrorKind::IO => {
format!(
"File {} was found, but it could not be loaded",
self.path
)
},
AssetErrorKind::NotFound => {
String::from("The file was not found in the searched path")
},
AssetErrorKind::UTF8 => String::from(
"UTF8 decoding error: is the file properly encoded?",
),
AssetErrorKind::Unknown => {
String::from("An unknown error happened.")
},
};
if let Some(error) = &self.io_error {
message = format!(
"{message}\n\
The following I/O error has happened: \n{error:?}"
);
}
if let Some(error) = &self.utf8_error {
message = format!(
"{message}\n\
The following encoding error has happened: \n{error:?}"
);
}
write!(f, "{message}")
}
}
#[derive(Debug)]
struct Asset {
blob: Option<Vec<u8>>,
text: Option<String>,
mime: mime::Mime,
}
impl Asset {
fn new(blob: &[u8], mime: mime::Mime) -> Result<Asset, AssetError> {
match mime.kind() {
mime::Kind::Text => Ok(Asset {
text: Some(String::from_utf8(blob.to_vec())?),
blob: None,
mime,
}),
mime::Kind::Font | mime::Kind::Image | mime::Kind::Blob => {
Ok(Asset {
text: None,
blob: Some(blob.to_vec()),
mime,
})
},
}
}
fn from_str(str: &str, mime: mime::Mime) -> Asset {
match mime.kind() {
mime::Kind::Text => Asset {
text: Some(String::from(str)),
blob: None,
mime,
},
mime::Kind::Font | mime::Kind::Image | mime::Kind::Blob => Asset {
text: None,
blob: Some(String::from(str).into_bytes()),
mime,
},
}
}
}
/// Given a relative path, returns the file contents or a default fallback.
///
/// The `path` argument is relative to the `static/public` directory.
///
/// Defaults are found in the `fixed::DEFAULTS` map.
///
/// Returns a `FallbackError` if neither is found or an I/O error occurred.
fn fallback(path: &str, graph: &Graph) -> Result<Asset, AssetError> {
let target = format!("static/public/assets/{path}");
let defaults: HashMap<&str, &str> = TEXTS.iter().copied().collect();
let fonts: HashMap<&str, &'static Font> = FONTS.iter().copied().collect();
let mime = mime::Mime::guess(path);
match std::fs::read(&target) {
// A matching file exists on disk and is accessible
Ok(content) => Ok(Asset {
blob: Some(content),
text: None,
mime,
}),
Err(io_error) => {
// A matching file does not exist on disk
if io_error.kind() == ErrorKind::NotFound {
if let Some(content) = defaults.get(path) {
Ok(Asset::from_str(content, mime))
} else {
let not_found_error = Err(AssetError::new(
path,
AssetErrorKind::NotFound,
Some(io_error),
None,
));
if !graph.meta.config.serve_fonts {
return not_found_error
}
match fonts.get(path) {
// A matching font exists
Some(content) => Asset::new(content.blob, mime),
None => not_found_error,
}
}
// A matching file exists on disk and is not accessible
} else {
Err(AssetError::new(
path,
AssetErrorKind::IO,
Some(io_error),
None,
))
}
},
}
}
/// Handles requests for static files.
///
/// This handler receives and extracts requests from `/static/{path}`.
pub async fn file(
Path(path): Path<String>,
State(state): State<GlobalState>,
) -> Response<Body> {
let instant = now();
match fallback(&path, &state.graph) {
Ok(asset) => {
let response = assemble(asset, &state.graph);
tlog!(
&instant,
"Assembled {} response for {path}",
response.status()
let target = format!("static/public/{path}");
let content = match std::fs::read(&target) {
Ok(s) => s,
Err(e) => {
let mut error_message = String::from(
"The requested file does not exist, the server does not have \
permission to access it or a filesystem error ocurred.",
);
response
},
Err(asset_error) => {
let mut error_message =
if matches!(asset_error.kind, AssetErrorKind::NotFound) {
String::from("The requested file was not found.")
} else {
String::from(
"The requested file exists, but the server lacks \
permission to access it or another I/O error occurred.",
)
};
if log::env_level() >= DEBUG {
error_message = format!(
"<p>{error_message}</p>\
<p>Targeted path: <code>{path}</code></p>\
<p>Error:</p> <pre>{asset_error}</pre>"
<p>Targeted path: <code>{target}</code></p>\
<p>Error message:</p> <pre>{e}</pre>"
);
}
log!(ERROR, "{error_message}");
error::make(Some(404), Some(&error_message), &state.graph)
return super::error::by_code(
Some(404),
Some(&error_message),
&state.graph,
);
},
};
let mut response = Response::new(Body::from(content));
*response.status_mut() = StatusCode::OK;
let header = header::CONTENT_TYPE;
let content_type = Mime::guess(&path);
if let Ok(header_value) =
HeaderValue::from_str(&String::from(content_type.clone()))
{
response.headers_mut().append(header, header_value);
} else {
log!(
WARN,
"Failed to create content type header value from {content_type:?}"
);
}
tlog!(&instant, "Assembled response for {content_type:?} {path}");
response
}
pub async fn serial(
@ -315,7 +70,7 @@ pub async fn serial(
let config = &state.graph.meta.config;
let make_error = |code: u16, message: &str| -> Response<Body> {
handlers::error::make(
handlers::error::by_code(
Some(code),
Some(
format!(
@ -373,258 +128,9 @@ pub async fn serial(
}
}
static TEXTS: &[(&str, &str)] = &[
(
"assets/style.css",
include_str!("../../../static/public/assets/style.css"),
),
(
"assets/fonts/fonts.css",
include_str!("../../../static/public/assets/fonts/fonts.css"),
),
(
"assets/favicon.svg",
include_str!("../../../static/public/assets/favicon.svg"),
),
];
pub static FONTS: &[(&str, &Font)] = &[
(
"assets/fonts/cormorant/cormorant-infant-latin-300-normal.woff2",
&Font {
name: "Cormorant Infant",
attribution: &Attribution {
project_name: "Cormorant",
author: "Christian Thalmann",
project_url: "https://github.com/CatharsisFonts/Cormorant",
author_url: "https://github.com/CatharsisFonts",
license_header: include_str!(
"../../../static/public/assets/fonts/\
cormorant/header.LICENSE"
),
},
blob: include_bytes!(
"../../../static/public/assets/fonts/\
cormorant/cormorant-infant-latin-300-normal.woff2"
),
license: &OFL,
},
),
(
"assets/fonts/cormorant/cormorant-infant-latin-300-italic.woff2",
&Font {
name: "Cormorant Infant Italic",
attribution: &Attribution {
project_name: "Cormorant",
author: "Christian Thalmann",
project_url: "https://github.com/CatharsisFonts/Cormorant",
author_url: "https://github.com/CatharsisFonts",
license_header: include_str!(
"../../../static/public/assets/fonts/\
cormorant/header.LICENSE"
),
},
blob: include_bytes!(
"../../../static/public/assets/fonts/\
cormorant/cormorant-infant-latin-300-italic.woff2"
),
license: &OFL,
},
),
(
"assets/fonts/maven/maven-pro-latin-400-normal.woff2",
&Font {
name: "Maven Pro",
attribution: &Attribution {
project_name: "Maven",
author: "Joe Prince and Project Authors",
author_url: "https://github.com/m4rc1e/mavenproFont/blob/\
main/AUTHORS.txt",
project_url: "https://github.com/m4rc1e/mavenproFont",
license_header: include_str!(
"../../../static/public/assets/fonts/\
maven/header.LICENSE"
),
},
blob: include_bytes!(
"../../../static/public/assets/fonts/\
maven/maven-pro-latin-400-normal.woff2"
),
license: &OFL,
},
),
(
"assets/fonts/mononoki/mononoki-latin-400-normal.woff2",
&Font {
name: "Mononoki",
attribution: &Attribution {
project_name: "Mononoki",
author: "Matthias Tellen",
author_url: "https://github.com/madmalik",
project_url: "https://madmalik.github.io/mononoki/",
license_header: include_str!(
"../../../static/public/assets/fonts/\
mononoki/header.LICENSE"
),
},
blob: include_bytes!(
"../../../static/public/assets/fonts/\
mononoki/mononoki-latin-400-normal.woff2"
),
license: &OFL,
},
),
(
"assets/fonts/rawengulk/RawengulkLight.woff2",
&Font {
name: "Rawengulk Light",
attribution: &Attribution {
project_name: "Rawengulk",
author: "gluk Fonts",
author_url: "https://www.glukfonts.pl",
project_url: "https://www.glukfonts.pl/font.php?font=Rawengulk",
license_header: include_str!(
"../../../static/public/assets/fonts/\
rawengulk/header.LICENSE"
),
},
license: &OFL,
blob: include_bytes!(
"../../../static/public/assets/fonts/\
rawengulk/RawengulkLight.woff2"
),
},
),
(
"assets/fonts/reforma/Reforma1969-Blanca.woff2",
&Font {
name: "Reforma 1969 Blanca",
attribution: &REFORMA_ATTRIBUTION,
license: &CCND,
blob: include_bytes!(
"../../../static/public/assets/fonts/\
reforma/Reforma1969-Blanca.woff2"
),
},
),
(
"assets/fonts/reforma/Reforma1969-BlancaItalica.woff2",
&Font {
name: "Reforma 1969 Blanca Italica",
attribution: &REFORMA_ATTRIBUTION,
license: &CCND,
blob: include_bytes!(
"../../../static/public/assets/fonts/\
reforma/Reforma1969-BlancaItalica.woff2"
),
},
),
(
"assets/fonts/reforma/Reforma1969-Gris.woff2",
&Font {
name: "Reforma 1969 Blanca Gris",
attribution: &REFORMA_ATTRIBUTION,
license: &CCND,
blob: include_bytes!(
"../../../static/public/assets/fonts/\
reforma/Reforma1969-Gris.woff2"
),
},
),
(
"assets/fonts/reforma/Reforma1969-GrisItalica.woff2",
&Font {
name: "Reforma 1969 Blanca Gris Italica",
attribution: &REFORMA_ATTRIBUTION,
license: &CCND,
blob: include_bytes!(
"../../../static/public/assets/fonts/\
reforma/Reforma1969-GrisItalica.woff2"
),
},
),
];
static REFORMA_ATTRIBUTION: Attribution = Attribution {
project_name: "Reforma",
project_url: "https://pampatype.com/reforma",
author: "PampaType",
author_url: "https://pampatype.com",
license_header: include_str!(
"../../../static/public/assets/fonts/\
reforma/header.LICENSE"
),
};
#[derive(Serialize)]
pub struct Font<'f> {
name: &'f str,
attribution: &'f Attribution<'f>,
license: &'f License<'f>,
blob: &'f [u8],
}
#[derive(Serialize)]
pub struct Attribution<'a> {
project_name: &'a str,
project_url: &'a str,
author: &'a str,
author_url: &'a str,
license_header: &'a str,
}
#[derive(Serialize)]
pub struct License<'l> {
name: &'l str,
kind: &'l LicenseKind,
text: &'l str,
url: &'l str,
}
#[derive(Serialize)]
#[expect(non_camel_case_types, clippy::upper_case_acronyms)]
pub enum LicenseKind {
SIL_OFL_1_1,
CC_BY_ND_4_0_INTERNATIONAL,
}
impl std::fmt::Display for LicenseKind {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let s = match self {
LicenseKind::SIL_OFL_1_1 => "SIL Open Font License 1.1",
LicenseKind::CC_BY_ND_4_0_INTERNATIONAL => {
"Creative Commons Attribution-NoDerivatives 4.0 International"
},
};
write!(f, "{s}")
}
}
static OFL: License = License {
name: "SIL Open Font License 1.1",
kind: &LicenseKind::SIL_OFL_1_1,
url: "assets/licenses/SIL_OFL_1_1.txt",
text: include_str!(
"../../../static/public/assets/fonts/_canon/SIL_OFL_1_1.body.LICENSE"
),
};
static CCND: License = License {
name: "Creative Commons Attribution-NoDerivatives 4.0 International",
kind: &LicenseKind::CC_BY_ND_4_0_INTERNATIONAL,
url: "/assets/licenses/CC_BY_ND_4_0_INTERNATIONAL.txt",
text: include_str!(
"../../../static/public/assets/fonts/_canon/\
CC_BY_ND_4_0_INTERNATIONAL.body.LICENSE"
),
};
#[cfg(test)]
mod tests {
use axum::http::status::StatusCode;
use super::*;
use crate::router::handlers::mime::Mime;
async fn wrap_serial(format: &str) -> Response<Body> {
let state = GlobalState {
@ -662,218 +168,4 @@ mod tests {
== "application/json"
);
}
#[tokio::test]
async fn not_found() {
let state = GlobalState {
graph: Graph::default(),
};
let response = file(Path("/k/j/m".to_string()), State(state)).await;
assert!(response.status() == StatusCode::NOT_FOUND);
}
#[test]
fn error_from_utf8error() {
let bytes = vec![0, 159];
let utf8error = String::from_utf8(bytes.clone()).unwrap_err();
let error = AssetError::from(utf8error);
assert!(error.utf8_error.is_some());
assert_eq!(error.utf8_error.unwrap().into_bytes(), bytes);
}
#[test]
fn error_from_string() {
let payload = "r5MDnkEojW9HZDAG";
let asset_error = AssetError::from(payload.to_string());
println!("{asset_error}");
assert!(asset_error.path.contains(payload));
}
#[test]
fn new_text_asset() {
let asset = Asset::new(&[1, 0, 1], mime::Mime::Txt).unwrap();
assert!(asset.blob.is_none());
assert!(asset.text.is_some());
assert_eq!(asset.text.unwrap(), "\u{1}\0\u{1}");
}
#[test]
fn new_blob_asset() {
let asset = Asset::new(&[1, 0, 1], mime::Mime::Png).unwrap();
assert!(asset.blob.is_some());
assert!(asset.text.is_none());
assert_eq!(asset.blob.unwrap(), &[1, 0, 1]);
}
#[test]
fn asset_from_str() {
let payload = "\u{1}\0\u{6}";
let asset = Asset::from_str(payload, mime::Mime::Ico);
assert_eq!(asset.blob.unwrap(), &[1, 0, 6]);
}
#[test]
fn new_asset_utf8_error() {
let bad_bytes = [0xff, 0xc0, 0xf5, 0xc1, 0x80];
let error = Asset::new(&bad_bytes, mime::Mime::Txt).unwrap_err();
assert!(matches!(&error.kind, AssetErrorKind::UTF8));
assert!(format!("{error}").contains("UTF8 decoding error"));
}
#[test]
fn not_found_asset_error() {
let error = fallback("not_found.png", &Graph::default()).unwrap_err();
assert!(matches!(&error.kind, AssetErrorKind::NotFound));
assert!(
format!("{error}")
.contains("The file was not found in the searched path")
);
}
#[test]
fn assemble_from_blob() {
let asset = Asset::new(&[1, 0, 1], Mime::Pdf).unwrap();
let response = assemble(asset, &Graph::default());
let content_type =
response.headers().get(header::CONTENT_TYPE).unwrap();
assert_eq!(content_type, "application/pdf");
}
}
#[cfg(test)]
#[cfg(unix)]
#[expect(clippy::panic_in_result_fn, clippy::unwrap_in_result)]
mod serial_tests {
use std::{fs, os::unix::fs::PermissionsExt as _, path::PathBuf};
use super::*;
use crate::{
dev::test::{Directories, Error},
router::handlers::mime::Mime,
};
#[test]
fn io_asset_error() -> Result<(), Error> {
let dirs = Directories::setup("io_asset_error")?;
let assets = dirs.assets.clone();
let file = assets.join("unreadable.png");
fs::write(&file, [1, 0, 1])?;
let mut permissions = fs::metadata(&file)?.permissions();
permissions.set_mode(0o200);
fs::set_permissions(&file, permissions)?;
let new_permissions = fs::metadata(&file)?.permissions();
assert_eq!(new_permissions.mode() & 0o777, 0o200);
let error = fallback("unreadable.png", &Graph::default()).unwrap_err();
assert!(matches!(&error.kind, AssetErrorKind::IO));
assert!(
format!("{error}")
.contains("was found, but it could not be loaded")
);
Ok(())
}
#[test]
fn target_file_exists() -> Result<(), Error> {
let dirs = Directories::setup("target_file_exists")?;
let assets = dirs.assets.clone();
let file = assets.join("asset.woff2");
fs::write(&file, [1, 0, 1])?;
let asset = fallback("asset.woff2", &Graph::default()).unwrap();
assert!(asset.text.is_none());
assert!(asset.blob.is_some());
assert!(matches!(asset.mime, Mime::Woff2));
Ok(())
}
#[test]
fn default_font_found_if_serving_enabled() -> Result<(), Error> {
let dirs = Directories::setup("font_found_if_serving_enabled")?;
let assets = dirs.assets.clone();
let relative_font_path =
PathBuf::from(FONTS[0].0.replace("assets/", ""));
let font_path = assets.join(&relative_font_path);
let font_dir = font_path.parent().expect("failed getting font dir");
println!("{font_dir:?}");
fs::create_dir_all(font_dir)?;
fs::write(&font_path, [1, 0, 1])?;
let graph = Graph::from_serial(
"[meta.config]\nserve_fonts = true",
&Format::TOML,
)
.expect("failed instantiating graph");
println!("{font_path:?}");
let asset = fallback(relative_font_path.to_str().unwrap(), &graph)
.expect("fallback failed");
assert!(asset.text.is_none());
assert!(asset.blob.is_some());
assert!(matches!(asset.mime, Mime::Woff2));
Ok(())
}
#[test]
fn custom_font_found_if_serving_enabled() -> Result<(), Error> {
let dirs = Directories::setup("font_found_if_serving_enabled")?;
let assets = dirs.assets.clone();
let relative_font_path = "fonts/custom.ttf";
let font_path = assets.join(relative_font_path);
let font_dir = font_path.parent().unwrap();
fs::create_dir_all(font_dir)?;
fs::write(&font_path, [1, 0, 1])?;
let graph = Graph::from_serial(
"[meta.config]\nserve_fonts = true",
&Format::TOML,
)
.expect("failed instantiating graph");
let asset =
fallback(relative_font_path, &graph).expect("fallback failed");
assert!(asset.text.is_none());
assert!(asset.blob.is_some());
assert!(matches!(asset.mime, Mime::Ttf));
Ok(())
}
#[test]
fn font_not_found_if_serving_disabled() -> Result<(), Error> {
let dirs = Directories::setup("target_file_exists")?;
let assets = dirs.assets.clone();
let relative_font_path =
PathBuf::from(FONTS[0].0.replace("assets/", ""));
let font_path = assets.join(&relative_font_path);
let font_dir = font_path.parent().unwrap();
fs::create_dir_all(font_dir)?;
fs::write(&font_path, [1, 0, 1])?;
let graph = Graph::from_serial(
"[meta.config]\nserve_fonts = false",
&Format::TOML,
)
.unwrap();
let error = fallback(font_path.to_str().unwrap(), &graph).unwrap_err();
assert!(matches!(error.kind, AssetErrorKind::NotFound));
Ok(())
}
}

55
src/router/handlers/graph.rs
View file

@ -1,8 +1,7 @@
use axum::{
body::Body,
extract::{Path, State},
http::Response,
response::{IntoResponse as _, Redirect},
extract::State,
response::IntoResponse as _,
{body::Body, extract::Path, http::Response, response::Redirect},
};
use crate::{
@ -18,11 +17,18 @@ pub async fn node(
let instant = now();
let result = state.graph.find_node(&id);
let found = result.node.is_some();
let node = result.node.unwrap_or(Node::not_found(Some(format!(
"Could not find node ID {id}."
))));
let node = result
.node
.unwrap_or(Node::new(Some(format!("Could not find node ID {id}."))));
if found && (!result.exact || result.redirect) {
if !node.redirect.is_empty() {
return Redirect::permanent(
format!("/node/{}", node.redirect).as_str(),
)
.into_response();
}
if found && !result.exact {
return Redirect::permanent(format!("/node/{}", node.id).as_str())
.into_response();
}
@ -37,20 +43,26 @@ pub async fn node(
"node",
&context,
if found { 500 } else { 404 },
Some(format!(
Some(
format!(
"Failed to generate page for node {} (ID {}).",
node.title, id
)),
)
.to_owned(),
),
!found,
)
}
#[cfg(test)]
mod tests {
use axum::http::{HeaderName, StatusCode};
use axum::{
http::{HeaderName, StatusCode},
};
use crate::graph::Graph;
use super::*;
use crate::graph::{Format, Graph};
async fn wrap_node(query: &str) -> Response<Body> {
let state = GlobalState {
@ -93,24 +105,7 @@ mod tests {
#[tokio::test]
async fn docs_redirect() {
let response = wrap_node("RedirectTest").await;
assert_eq!(response.status(), StatusCode::PERMANENT_REDIRECT);
}
#[tokio::test]
async fn standalone_graph_redirect() {
let toml = "\
[nodes.n1]\n\
redirect = 'n2'\n\
\n\
[nodes.n2]\n\
text = 'n2 text'\n\
";
let graph = Graph::from_serial(toml, &Format::TOML).unwrap();
let state = GlobalState { graph };
let response =
node(Path("n1".to_string()), axum::extract::State(state)).await;
let response = wrap_node("docs").await;
assert_eq!(response.status(), StatusCode::PERMANENT_REDIRECT);
}
}

74
src/router/handlers/mime.rs
View file

@ -83,17 +83,7 @@ impl From<Mime> for String {
}
}
pub enum Kind {
Text,
Font,
Image,
Blob,
}
impl Mime {
/// Guesses the mimetype given the extension of a filename or path.
///
/// Only considers the last dot-delimited fragment of `path`.
pub fn guess(path: &str) -> Mime {
if let Some(pair) = path.rsplit_once('.') {
Mime::from(pair.1)
@ -101,68 +91,4 @@ impl Mime {
Mime::Unknown
}
}
/// Returns one of four kind of mimetypes among text, font, image and blob.
///
/// This is mainly used when serving assets through the `fixed` module in
/// order to determine what `Asset` field to use when assemblimg a response
/// body.
pub const fn kind(&self) -> Kind {
use Mime::*;
match self {
Txt | Csv | Css | Toml | Xml | Json | Js | Svg => Kind::Text,
Ttf | Otf | Woff | Woff2 => Kind::Font,
Ico | Jpeg | Png | Apng | Gif | Webp | Avif => Kind::Image,
Pdf | Epub | Unknown => Kind::Blob,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn smoke() {
let m = Mime::guess("/home/jane/top/inner/kitty.png");
assert_eq!(String::from(m), "image/png");
}
#[test]
fn all() {
let pairs = [
("file.txt", "text/plain"),
("file.csv", "text/csv"),
("file.css", "text/css"),
("file.ttf", "font/ttf"),
("file.otf", "font/otf"),
("file.woff", "font/woff"),
("file.woff2", "font/woff2"),
("file.svg", "image/svg+xml"),
("file.ico", "image/x-icon"),
("file.jpeg", "image/jpeg"),
("file.png", "image/png"),
("file.apng", "image/apng"),
("caddy.gif", "image/gif"),
("file.webp", "image/webp"),
("file.avif", "image/avif"),
("file.toml", "application/toml"),
("file.xml", "application/xml"),
("file.json", "application/json"),
("file.js", "text/javascript"),
("file.pdf", "application/pdf"),
("book.epub", "application/epub+zip"),
("weird.xzx", "application/octet-stream"),
];
for (file, mime) in pairs {
assert_eq!(String::from(Mime::guess(file)), mime);
}
}
#[test]
fn unknown() {
let u = Mime::guess("x");
assert!(matches!(u, Mime::Unknown));
}
}

16
src/router/handlers/navigation.rs
View file

@ -1,6 +1,4 @@
use axum::{
Form, body::Body, extract::State, http::Response, response::Redirect,
};
use axum::{Form, body::Body, extract::State, http::Response, response::Redirect};
use crate::{
prelude::*,
@ -15,14 +13,6 @@ pub async fn about(State(state): State<GlobalState>) -> Response<Body> {
handlers::template::with_graph("about", state).await
}
pub async fn legal(State(state): State<GlobalState>) -> Response<Body> {
let mut context = tera::Context::default();
context.insert("graph", &state.graph);
context.insert("fonts", &crate::router::handlers::fixed::FONTS);
handlers::template::with_context("legal", &context, 500, None, false)
}
pub async fn tree(State(state): State<GlobalState>) -> Response<Body> {
let instant = now();
@ -41,7 +31,7 @@ pub async fn data(State(state): State<GlobalState>) -> Response<Body> {
let mut detached_pairs: Vec<(String, u32)> =
state.graph.stats.detached.clone().into_iter().collect();
detached_pairs.sort_by_key(|b| std::cmp::Reverse(b.1));
detached_pairs.sort_by(|a, b| b.1.cmp(&a.1));
let mut context = tera::Context::default();
context.insert("graph", &state.graph);
@ -68,9 +58,9 @@ pub struct Query {
#[cfg(test)]
mod tests {
use axum::http::StatusCode;
use crate::graph::Graph;
use super::*;
use crate::graph::Graph;
async fn wrap_page(path: &str) -> Response<Body> {
let state = GlobalState {

2
src/router/handlers/raw.rs
View file

@ -1,6 +1,6 @@
use axum::{
body::Body,
http::{HeaderValue, Response, StatusCode, header},
http::{header, HeaderValue, Response, StatusCode},
};
use crate::prelude::*;

514
src/router/handlers/template.rs
View file

@ -1,17 +1,14 @@
use std::{collections::HashMap, fs, io::ErrorKind, path::PathBuf};
use axum::{
body::Body,
http::{Response, StatusCode, header},
http::{header, Response, StatusCode},
};
use crate::{
dev::log,
prelude::*,
router::{GlobalState, handlers::raw::make_response},
};
/// Assembles a response containing the graph as its only context.
/// Assembles a response containing the graph as its only context
///
/// The template name **must not** contain the extension.
#[expect(clippy::unused_async)]
@ -34,190 +31,50 @@ pub(in crate::router::handlers) fn with_context(
error_message: Option<String>,
is_error: bool,
) -> Response<Body> {
match render(name, context, error_message) {
Ok(rendered) => {
let status_code = if is_error { error_code } else { rendered.code };
make_response(
&rendered.html,
status_code,
&[(header::CONTENT_TYPE, "text/html")],
)
},
Err(error) => make_response(
&error.template.html,
error.template.code,
&[(header::CONTENT_TYPE, "text/html")],
),
}
let (body, render_status) = render(name, context, error_message);
let status_code = if is_error { error_code } else { render_status };
make_response(&body, status_code, &[(header::CONTENT_TYPE, "text/html")])
}
#[derive(Debug)]
pub struct Rendered {
pub html: String,
pub code: u16,
}
impl Rendered {
fn ok(html: &str) -> Rendered {
Rendered {
code: 200,
html: String::from(html),
}
}
}
#[derive(Debug)]
pub struct RenderingError {
pub message: String,
pub template: Rendered,
}
impl RenderingError {
fn new(message: &str, code: u16, error: &tera::Error) -> RenderingError {
RenderingError {
message: String::from(message),
template: Rendered {
html: emergency_wrap(error, message),
code,
},
}
}
fn with_template(
message: &str,
code: u16,
template: &str,
) -> RenderingError {
RenderingError {
message: String::from(message),
template: Rendered {
html: String::from(template),
code,
},
}
}
}
impl std::fmt::Display for RenderingError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "Rendering Error: {}", self.message)
}
}
static DEFAULTS: &[(&str, &str)] = &[
("base.html", include_str!("../../../templates/base.html")),
("index.html", include_str!("../../../templates/index.html")),
("about.html", include_str!("../../../templates/about.html")),
("legal.html", include_str!("../../../templates/legal.html")),
("data.html", include_str!("../../../templates/data.html")),
("empty.html", include_str!("../../../templates/empty.html")),
("error.html", include_str!("../../../templates/error.html")),
("node.html", include_str!("../../../templates/node.html")),
("tree.html", include_str!("../../../templates/tree.html")),
];
fn read_template(name: &str, path: PathBuf) -> Result<String, std::io::Error> {
let defaults: HashMap<&str, &str> = DEFAULTS.iter().copied().collect();
match fs::read_to_string(path) {
Ok(content) => Ok(content),
Err(error) if error.kind() == ErrorKind::NotFound => {
match defaults.get(name) {
Some(default) => Ok(default.to_string()),
None => Err(error),
}
},
Err(error) => Err(error),
}
}
fn load_templates() -> Result<tera::Tera, tera::Error> {
let mut tera = tera::Tera::default();
let root = PathBuf::from("templates");
let default_names: Vec<&str> = DEFAULTS.iter().map(|(n, _)| *n).collect();
match fs::read_dir(&root) {
Ok(dir) => {
log!(
DEBUG,
"Reading templates from root directory '{}', canonically {:?}",
root.display(),
root.canonicalize()
);
for file_opt in dir {
let file = file_opt?;
let path = file.path();
if path.is_file() {
if let Some(name) = path.clone().file_name() {
let Some(name_str) = name.to_str() else {
return Err(tera::Error::msg(format!(
"Template filename {} is not valid unicode",
name.display()
)))
};
if !default_names.contains(&name_str) {
tera.add_raw_template(
name_str,
&read_template(name_str, path)?,
)?;
}
}
}
}
},
Err(error) => {
log!(
VERBOSE,
"A 'templates' directory was not found or is not accessible: \
only built-in templates will be available"
);
if error.kind() != ErrorKind::NotFound {
return Err(tera::Error::msg(error.to_string()))
}
},
}
for tuple in DEFAULTS {
let path = root.join(tuple.0);
let name = tuple.0;
tera.add_raw_template(name, &read_template(name, path)?)?;
}
Ok(tera)
}
/// Renders a template into a String and error code.
/// Renderes a template into a String and error code
///
/// The template name **must not** contain the extension (e.g. `.html`).
pub(in crate::router::handlers) fn render(
template: &str,
// TODO take Option, skip context if None,
// then template_handler can replace static_template_handler
context: &tera::Context,
error_message: Option<String>,
) -> Result<Rendered, RenderingError> {
) -> (String, u16) {
let instant = now();
let tera = match load_templates() {
Ok(engine) => engine,
Err(error) => {
return Err(RenderingError::new(
"Failed instantiating template engine",
500,
&error,
))
// TODO just return an Option/String> here
let tera = match tera::Tera::new("./templates/**/*") {
Ok(t) => t,
Err(e) => {
return (emergency_wrap(&e), 500);
},
};
match tera.render(format!("{template}.html").as_str(), context) {
Ok(html) => {
Ok(t) => {
tlog!(&instant, "Rendered template {template}");
Ok(Rendered::ok(&html))
(t, 200)
},
Err(e) => {
let mut error_context = tera::Context::default();
let mut out_error_message = match error_message {
Some(s) => emergency_wrap(&e, &s),
None => emergency_wrap(&e, "Template render failed."),
Some(s) => format!(
"Template render failed.\n\
User message: {s},
Engine message:\n<pre>{e:#?}</pre>"
),
None => format!(
"Template render failed.\n\
Engine message:\n<pre>{e:#?}</pre>"
),
};
if log::env_level() >= VERBOSE {
@ -234,79 +91,54 @@ pub(in crate::router::handlers) fn render(
&StatusCode::INTERNAL_SERVER_ERROR.to_string(),
);
match tera.render("error.html", &error_context) {
Ok(rendered_error) => Err(RenderingError::with_template(
&out_error_message,
(
tera.render("error.html", &error_context)
.unwrap_or(out_error_message.clone()),
500,
&rendered_error,
)),
Err(error_rendering_error) => Err(RenderingError::new(
&format!(
"Failed to render an error message template for \
\"{out_error_message}\""
),
500,
&error_rendering_error,
)),
}
)
},
}
}
fn emergency_wrap(error: &tera::Error, message: &str) -> String {
fn emergency_wrap(error: &tera::Error) -> String {
log!(ERROR, "{error:#?}");
let message_element = format!("<p>{message}</p>");
format!(
"<!DOCTYPE html>\n\
<html>\n\
<head>\n\
<title>en Pre-Templating Error</title>\n
<meta \
http-equiv=\"Content-Type\" \
content=\"text/html; charset=utf-8\" >\n\
<meta name=\"viewport\" \
content=\"width=device-width, initial-scale=1\">\n\
<style>\n\
:root {{ color-scheme: light dark; }}\n\
* {{\n\
background: light-dark(#eee, #222);\n\
color: light-dark(#000, #f1e9e5);\n\
line-height: 1.6em;
}}\n\
pre {{ overflow: auto; }}\n\
</style>\n\
</head>\n\
<body>\n\
<h2><strong>en Early Pre-Templating Error</strong></h2>\n\
{message_element}\n\
<pre>\n\
{error:#?}\n\
</pre>\n\
<p>This error may indicate a malformed or missing template.</p>\n\
<p>If you haven't modified templates, please consider \
<a href=\"https://codeberg.org/jutty/en/issues\">\
reporting it</a>, including:\
</p>\n\
<ul>\n\
<li>The error message above</li>\n\
<li>en version: <code>{}</code></li>\n\
<li>If possible, your graph file's <code>[meta.config]</code> \
values and definition for this page.</li>\n\
</ul>\n\
</body>\n\
</html>\n\
",
env!("CARGO_PKG_VERSION")
r#"<!DOCTYPE html>
<html>
<head>
<title>Pre-Templating Error</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" >
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
@media (prefers-color-scheme: dark) {{
* {{ background-color: #222222;
color: #f1e9e5; }} }}
* {{ line-height: 1.6em; }}
pre {{ overflow: auto; }}
</style>
</head>
<body>
<h2><strong>Early Pre-Templating Error</strong></h2>
<p>This normally indicates a malformed template.</p>
<pre>
{error:#?}
</pre>
<p>
If you haven't modified templates, plese consider
<a href="https://codeberg.org/jutty/en/issues">reporting it</a>.
</p>
</body>
</html>
"#
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::graph::Graph;
use super::*;
#[test]
fn by_filename_forced_error() {
let response =
@ -344,68 +176,43 @@ mod tests {
fn render_with_context() {
let payload = "dBgIw8DnNHxJojiXzu445qUC4UpxwZCy";
let mut context = tera::Context::default();
let node = crate::graph::Node::not_found(Some(payload.to_string()));
let node = crate::graph::Node::new(Some(payload.to_string()));
let graph = Graph::load();
context.insert("node", &node);
context.insert("graph", &graph);
context.insert("incoming", &graph.incoming.get(&node.id));
match render("node", &context, None) {
Ok(rendered) => {
assert_eq!(rendered.code, 200);
assert!(rendered.html.matches(payload).count() == 1);
},
Err(error) => {
panic!("Errored on template generation with {error:?}")
},
}
let (body, status) = render("node", &context, None);
assert_eq!(status, 200);
assert!(body.matches(payload).count() == 1);
}
#[test]
fn render_custom_error_message() {
let payload = "dBgIw8DnNHxJojiXzu445qUC4UpxwZCy";
match render(
let (body, status) = render(
"ObH9jYUl4wMhUNcXnuqwVVzHoqx4ufyN",
&tera::Context::default(),
Some(payload.to_string()),
) {
Ok(_) => panic!("Got Ok, expected Error"),
Err(error) => {
assert_eq!(error.template.code, 500);
assert!(error.template.html.matches(payload).count() == 1);
},
}
);
assert_eq!(status, 500);
assert!(body.matches(payload).count() == 1);
}
#[test]
fn render_empty() {
match render(
let (body, status) = render(
"R8D1pxwHZDxcH5SMjR7rZEnIzmpkiHkH",
&tera::Context::default(),
None,
) {
Ok(_) => panic!("Got Ok, expected Error"),
Err(error) => {
assert_eq!(error.template.code, 500);
assert!(
error
.template
.html
.matches("Template render failed")
.count()
== 1
);
},
}
assert_eq!(status, 500);
assert!(body.matches("Template render failed").count() == 1);
}
#[test]
fn render_not_found() {
let payload = "OL6kb9qHe7Iwr7wFIRKUTeFhF34BRsQo";
let (body, status) =
match render(payload, &tera::Context::default(), None) {
Ok(_) => panic!("Got Ok, expected Error"),
Err(error) => (error.template.html, error.template.code),
};
let (body, status) = render(payload, &tera::Context::default(), None);
assert!(body.matches("TemplateNotFound").count() > 0);
assert!(body.matches(payload).count() > 0);
@ -414,11 +221,7 @@ mod tests {
#[test]
fn render_bad_context() {
let (body, status) =
match render("node", &tera::Context::default(), None) {
Ok(_) => panic!("Got Ok, expected Error"),
Err(error) => (error.template.html, error.template.code),
};
let (body, status) = render("node", &tera::Context::default(), None);
assert!(body.matches("Template render failed.").count() > 0);
assert_eq!(status, 500);
}
@ -427,174 +230,7 @@ mod tests {
fn emergency_wrap_custom_message() {
let payload = "JLaTtsnd2IFukIOvqFNymeuiaS6nMaUc";
let error = tera::Error::msg(payload);
let html = emergency_wrap(&error, "");
let html = emergency_wrap(&error);
assert!(html.matches(payload).count() == 1);
}
#[test]
fn default_templates_exist_and_match() {
let templates_dir =
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("templates");
for (map_name, map_contents) in DEFAULTS {
let path = templates_dir.join(map_name);
assert!(path.exists());
assert!(path.is_file());
let contents = fs::read_to_string(&path).unwrap();
assert_eq!(&contents, map_contents);
}
}
#[test]
fn rendering_error_html_contains_inner_error() {
let outer_payload = "Gl0c7CyArjlG1Zgvj3D5BFmZT6zRz5Ky";
let inner_payload = "t53pvXCf0JqUzwiM5BZbYxAQadYSJ9XW";
let inner_error = tera::Error::msg(inner_payload);
let error = RenderingError::new(outer_payload, 501, &inner_error);
assert!(error.template.html.contains(inner_payload));
assert!(error.template.html.contains(outer_payload));
}
#[test]
fn rendering_error_display() {
let payload = "4LKNOSqfW0Ys3LALDAond8IIp5RgN7vK";
let error = RenderingError::new(payload, 501, &tera::Error::msg(""));
let display_string = format!("{error}");
assert!(display_string.contains(payload));
}
#[test]
fn empty_template_read_is_an_error() {
let result = read_template("", PathBuf::from(""));
assert!(result.is_err());
}
#[test]
fn template_read_without_permissions_is_an_error() {
let result = read_template("", PathBuf::from("/etc/shadow"));
assert!(result.is_err());
}
#[test]
fn template_read_without_a_default_is_an_error() {
let result = read_template(
"xkQwFZpqf5iz",
PathBuf::from("templates/Boy5CZQUk2oX"),
);
assert!(result.is_err());
}
#[test]
fn template_read_with_a_default_is_ok() {
let result =
read_template("base.html", PathBuf::from("templates/St1iFgeOrhCK"));
assert!(result.is_ok());
}
#[test]
fn template_read_with_a_file_is_ok() {
let result =
read_template("GpzjjAPhCTIr", PathBuf::from("templates/base.html"));
assert!(result.is_ok());
}
}
#[cfg(test)]
#[expect(clippy::panic_in_result_fn)]
mod serial_tests {
use std::{ffi::OsStr, os::unix::ffi::OsStrExt as _};
use super::*;
use crate::dev::test::{Directories, Error};
#[test]
#[cfg_attr(not(unix), ignore)]
fn invalid_utf8_template_filename() -> Result<(), Error> {
let dirs = Directories::setup("encoding")?;
let invalid_name = OsStr::from_bytes(&[0xff, 0xfe, 0x80]);
let file_path = dirs.templates.join(invalid_name);
fs::write(file_path, b"")?;
let template_load_result = load_templates();
let err = template_load_result.err().unwrap();
let error_message = err.to_string();
assert!(error_message.contains("not valid unicode"));
Ok(())
}
#[test]
fn custom_template() -> Result<(), Error> {
let dirs = Directories::setup("custom_template")?;
let file_name = "custom.html";
let file_path = dirs.templates.join(file_name);
fs::write(file_path, b"")?;
let engine = load_templates()?;
assert!(engine.get_template_names().any(|t| t == "custom.html"));
Ok(())
}
#[test]
fn custom_template_inheritance_error() -> Result<(), Error> {
let dirs = Directories::setup("custom_template")?;
let file_name = "custom.html";
let file_path = dirs.templates.join(file_name);
fs::write(file_path, br#"{% extends "nonexistent.html" %}"#)?;
let template_load_result = load_templates();
assert!(template_load_result.is_err());
Ok(())
}
#[test]
fn inner_template_no_op() -> Result<(), Error> {
let dirs = Directories::setup("inner_template")?;
let inner_dir = dirs.templates.join("inner");
fs::create_dir(&inner_dir)?;
let inner_template = inner_dir.join("inner.html");
fs::write(inner_template, br#"{% extends "nonexistent.html" %}"#)?;
let engine = load_templates()?;
let default_count = dirs.original.join("templates").read_dir()?.count();
let template_count = engine.get_template_names().count();
assert!(template_count == default_count);
Ok(())
}
#[test]
fn templates_dir_not_found_ok() -> Result<(), Error> {
let dirs = Directories::setup("not_found_error")?;
std::fs::remove_dir_all(&dirs.templates)?;
let template_load_result = load_templates();
template_load_result?;
Ok(())
}
#[test]
// Unexpected here means any error other than 'not found'
fn templates_dir_unexpected_error() -> Result<(), Error> {
let dirs = Directories::setup("unexpected_error")?;
log!(DEBUG, "Working directory is {:?}", std::env::current_dir());
std::fs::remove_dir_all(&dirs.templates)?;
let templates = dirs.test.join("templates");
fs::write(&templates, b"")?;
let template_load_result = load_templates();
assert!(template_load_result.is_err());
Ok(())
}
}

34
src/syntax/command.rs
View file

@ -7,17 +7,11 @@ use crate::prelude::*;
static FIRST_PARSE: AtomicBool = AtomicBool::new(true);
#[derive(Clone, Debug, PartialEq, Eq)]
#[derive(Clone, Debug, PartialEq)]
pub struct Arguments {
pub hostname: String,
pub port: u16,
pub graph_path: PathBuf,
pub flags: Flags,
}
#[derive(Default, Clone, Debug, PartialEq, Eq)]
pub struct Flags {
pub version: bool,
}
impl Arguments {
@ -38,7 +32,6 @@ impl Default for Arguments {
hostname: String::from("0.0.0.0"),
port: 0,
graph_path: PathBuf::from("./static/graph.toml"),
flags: Flags::default(),
}
}
}
@ -46,33 +39,21 @@ impl Default for Arguments {
fn parse(defaults: &Arguments, args: &[String]) -> Arguments {
let mut out_args = defaults.clone();
// The first argument is usually the command path, but this is not
// guaranteed on all platforms so we drop it if it is unrecognized.
// For now, this is done simply by checking if it starts with a dash
let commandless_args = if let Some((head, tail)) = args.split_first() {
let filtered_args = if let Some((head, tail)) = args.split_first() {
if head.starts_with('-') { args } else { tail }
} else {
args
};
let mut nonflag_args: Vec<&str> = vec![];
for arg in commandless_args {
if arg == "--version" || arg == "-v" {
out_args.flags.version = true;
} else {
nonflag_args.push(arg);
}
}
for arg in nonflag_args.chunks(2) {
for arg in filtered_args.chunks(2) {
if let Some(argument) = arg.first()
&& let Some(parameter) = arg.get(1)
{
if *argument == "-h" || *argument == "--hostname" {
out_args.hostname = String::from(*parameter);
} else if *argument == "-p" || *argument == "--port" {
if argument.eq("-h") || argument.eq("--hostname") {
out_args.hostname = String::from(parameter);
} else if argument.eq("-p") || argument.eq("--port") {
out_args.port = parameter.parse().unwrap_or(out_args.port);
} else if *argument == "-g" || *argument == "--graph" {
} else if argument.eq("-g") || argument.eq("--graph") {
out_args.graph_path = PathBuf::from(parameter);
} else {
if FIRST_PARSE.load(Ordering::SeqCst) {
@ -97,7 +78,6 @@ mod tests {
hostname: String::from("localhost"),
port: 3007,
graph_path: PathBuf::default(),
flags: Flags::default(),
};
assert_eq!(args.make_address(), "localhost:3007");

48
src/syntax/content.rs
View file

@ -1,6 +1,4 @@
use std::mem::discriminant;
use parser::{Lexeme, Token};
use parser::{Token, Lexeme};
use crate::graph::Graph;
@ -23,48 +21,10 @@ pub struct TokenOutput {
pub format_tokens: Vec<Token>,
}
impl TokenOutput {
pub fn only(&self, kind: &Token) -> Vec<Token> {
let filter = |tokens: &[Token], k: &Token| -> Vec<Token> {
tokens
.iter()
.filter(|&t| discriminant(t) == discriminant(k))
.cloned()
.collect::<Vec<Token>>()
};
let filtered_tokens = filter(&self.tokens, kind);
let filtered_format_tokens = filter(&self.format_tokens, kind);
[filtered_tokens, filtered_format_tokens]
.into_iter()
.flatten()
.collect::<Vec<Token>>()
}
pub fn parse(text: &str, graph: &Graph) -> String {
parser::read(text, graph)
}
pub fn parse(text: &str, graph: &Graph) -> String { parser::read(text, graph) }
pub fn rich_parse(text: &str, graph: &Graph) -> TokenOutput {
parser::rich_read(
&text.replace("{{ en_version }}", env!("CARGO_PKG_VERSION")),
graph,
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::token::{Bold, Oblique};
#[test]
fn only() {
let graph = Graph::default();
let output = rich_parse("*four* *bold* and _two_ italic", &graph);
let bold_tokens = output.only(&Token::Bold(Bold::new(true)));
let italic_tokens = output.only(&Token::Oblique(Oblique::new(true)));
println!("{bold_tokens:?}");
assert_eq!(bold_tokens.len(), 4);
assert_eq!(italic_tokens.len(), 2);
}
parser::rich_read(text, graph)
}

116
src/syntax/content/parser.rs
View file

@ -1,21 +1,86 @@
use crate::{prelude::*, graph::Graph};
use super::{TokenOutput, Parseable as _, LexMap};
use token::{LineBreak, Literal};
use context::{Block, Inline};
pub use lexeme::Lexeme;
use lexer::{LEXMAP, lex};
pub use state::State;
pub use token::Token;
pub use {lexeme::Lexeme, token::Token, state::State};
use crate::{graph::Graph, prelude::*, syntax::content::TokenOutput};
pub mod context;
pub mod lexeme;
pub mod lexer;
pub mod point;
pub mod segment;
pub mod state;
pub mod token;
pub mod lexeme;
pub mod segment;
pub mod context;
pub mod point;
pub mod state;
fn parse(tokens: &[Token]) -> String {
tokens.iter().map(Token::render).collect::<String>()
const LEXMAP: LexMap = &[
(LineBreak::probe, |lexeme| {
Token::LineBreak(LineBreak::lex(lexeme))
}),
(Literal::probe, |lexeme| {
Token::Literal(Literal::lex(lexeme))
}),
];
fn lex(text: &str, map: LexMap, graph: &Graph, blocking: bool) -> TokenOutput {
let mut tokens: Vec<Token> = Vec::default();
let mut state = State::default();
let segments = segment::segment(text);
let lexemes = Lexeme::collect(&segments);
log!(VERBOSE, "Segments: {segments:?}");
let mut iterator = lexemes.iter().peekable();
while let Some(lexeme) = iterator.next() {
if lexeme.match_char('\\') {
if let Some(next) = iterator.next() {
tokens.push(Token::Literal(Literal::lex(next)));
}
continue;
}
if blocking {
if context::block::parse(
lexeme,
&mut state,
&mut tokens,
&mut iterator,
graph,
) {
continue;
}
}
if point::parse(lexeme, &mut state, &mut tokens, &mut iterator) {
continue;
}
if context::inline::parse(
lexeme,
&mut state,
&mut tokens,
&mut iterator,
graph,
) {
continue;
}
for (probe, lex) in map {
if probe(lexeme) {
let token = lex(lexeme);
log!(VERBOSE, "Lexmap lexed {lexeme} into {token}");
tokens.push(token);
break;
}
}
}
context::close(&state, &mut tokens);
TokenOutput {
tokens,
format_tokens: state.format_tokens,
text: None,
}
}
pub(super) fn read(input: &str, graph: &Graph) -> String {
@ -33,7 +98,7 @@ pub(super) fn rich_read(input: &str, graph: &Graph) -> TokenOutput {
}
/// Apply end-to-end point and inline parsing for nested formatting, such as
/// inside the display text of anchors and list items.
/// inside the display text of anchors and list items
pub fn format(input: &str, graph: &Graph) -> (String, Vec<Token>) {
let tokens = lex(input, LEXMAP, graph, false).tokens;
(parse(&tokens), tokens)
@ -47,12 +112,22 @@ pub fn flatten(input: &str, graph: &Graph) -> String {
flat
}
fn parse(tokens: &[Token]) -> String {
tokens.iter().map(Token::render).collect::<String>()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{graph::Graph, syntax::content::parser::token::header::Level};
use crate::{
graph::Graph,
syntax::content::parser::{token::header::Level},
};
fn read_noconfig(input: &str) -> String { read(input, &Graph::default()) }
use super::*;
fn read_noconfig(input: &str) -> String {
read(input, &Graph::default())
}
#[test]
fn empty_render_is_empty() {
@ -62,10 +137,7 @@ mod tests {
#[test]
fn mixed_sample() {
let en = "`this |test|` tries ## to |brea|k|: things";
let html = concat!(
r#"<p><code>this |test|</code> tries ## to <a "#,
r#"class="detached" title="" href="/node/k">brea</a>: things</p>"#,
);
let html = r#"<p><code>this |test|</code> tries ## to <a class="detached" title="" href="/node/k">brea</a>: things</p>"#;
assert_eq!(read_noconfig(en), html);
}

68
src/syntax/content/parser/context.rs
View file

@ -1,77 +1,58 @@
use crate::syntax::content::parser::{
State, Token,
token::{Header, Paragraph, Verse},
token::{Header, Paragraph, PreFormat},
};
pub mod anchor;
pub mod block;
pub mod inline;
pub mod anchor;
pub mod list;
pub mod preformat;
pub mod quote;
pub mod table;
#[derive(Clone, Default, Debug)]
#[derive(Clone, Debug)]
pub struct Context {
pub block: Block,
pub inline: Inline,
}
#[derive(Clone, Default, Debug)]
#[derive(Clone, Debug)]
pub enum Block {
Paragraph,
Header(u8), // level
List,
PreFormat,
Quote,
Table,
Verse,
#[default]
None,
}
#[derive(Clone, Default, Debug)]
#[derive(Clone, Debug)]
pub enum Inline {
Anchor,
Code,
#[default]
None,
}
/// # Panics
/// Panics if there is an open token at end of input that can't be easily
/// closed by simply adding a matching closing token. This normally is handled
/// by context parsers and probably indicates an error in one of them.
/// Panics if there is an open header or list at end of input.
pub fn close(state: &State, tokens: &mut Vec<Token>) {
match state.context.block {
Block::PreFormat => {
tokens.push(Token::PreFormat(PreFormat::new(false)));
},
Block::Paragraph => {
tokens.push(Token::Paragraph(Paragraph::new(false)));
},
Block::List => {
panic!("End of input with open list")
},
Block::Header(level) => {
tokens.push(Token::Header(Header::from_u8(level, false, None)));
},
Block::Verse => {
tokens.push(Token::Verse(Verse::new(false)));
},
Block::PreFormat => {
panic!("End of input with open preformat: {tokens:#?}")
},
Block::List => {
panic!("End of input with open list: {tokens:#?}")
},
Block::Quote => {
panic!("End of input with open quote: {tokens:#?}")
},
Block::Table => {
panic!("End of input with open table: {tokens:#?}")
},
Block::None => (),
}
}
#[cfg(test)]
mod tests {
use crate::syntax::content::parser::{State, context::Block};
use crate::syntax::content::parser::{context::Block, State};
#[test]
#[should_panic(expected = "End of input with open list")]
@ -80,27 +61,4 @@ mod tests {
state.context.block = Block::List;
super::close(&state, &mut vec![]);
}
#[test]
#[should_panic(expected = "End of input with open quote")]
fn open_quote_eoi() {
let mut state = State::default();
state.context.block = Block::Quote;
super::close(&state, &mut vec![]);
}
#[test]
#[should_panic(expected = "End of input with open table")]
fn open_table_eoi() {
let mut state = State::default();
state.context.block = Block::Table;
super::close(&state, &mut vec![]);
}
#[test]
fn open_verse_eoi() {
let mut state = State::default();
state.context.block = Block::Verse;
super::close(&state, &mut vec![]);
}
}

224
src/syntax/content/parser/context/anchor.rs
View file

@ -1,7 +1,7 @@
use crate::{
graph::Graph,
prelude::*,
syntax::content::parser::{Lexeme, State, Token, context::Inline},
syntax::content::parser::{context::Inline, Lexeme, State, Token},
graph::Graph,
};
/// Handles open anchor contexts until an anchor token is fully parsed.
@ -34,9 +34,6 @@ pub fn parse(
log!(VERBOSE, "End: Next lexeme is a pipe");
buffer.text.push_str(&lexeme.text());
candidate.set_text(&buffer.text.clone());
if buffer.text.starts_with('/') {
candidate.set_absolute(true);
}
} else {
log!(
VERBOSE,
@ -64,7 +61,7 @@ pub fn parse(
&& !lexeme.match_next_char('|')
{
log!(VERBOSE, "End: Plural anchor");
candidate.set_destination(Some(&candidate.text()));
candidate.set_destination(Some(&candidate.text().clone()));
candidate.text_push("s");
if lexeme.last() {
push(None, tokens, state, graph);
@ -76,7 +73,7 @@ pub fn parse(
if candidate.text().contains(':') {
candidate.set_external(true);
}
push(Some(&candidate.text()), tokens, state, graph);
push(Some(&candidate.text().clone()), tokens, state, graph);
} else {
push(Some(&buffer.destination.clone()), tokens, state, graph);
}
@ -87,13 +84,6 @@ pub fn parse(
"State: Found a pipe, but no boundary: destination follows"
);
candidate.set_balanced(true);
if lexeme.match_next_first_char('/') {
log!(
VERBOSE,
"State: Destination starts with a dash, marking as absolute"
);
candidate.set_absolute(true);
}
return true;
} else if lexeme.match_char(':') {
log!(VERBOSE, "State: Found a colon, marking anchor as external");
@ -172,9 +162,11 @@ fn push(
#[cfg(test)]
mod tests {
use crate::{graph::Graph, syntax::content::parser};
use crate::{syntax::content::parser, graph::Graph};
fn read(input: &str) -> String { parser::read(input, &Graph::default()) }
fn read(input: &str) -> String {
parser::read(input, &Graph::default())
}
#[test]
fn flanking() {
@ -196,10 +188,7 @@ mod tests {
fn flanking_with_trailing_comma_and_space() {
assert_eq!(
read("|Node|, at"),
concat!(
r#"<p><a class="detached" title="" "#,
r#"href="/node/Node">Node</a>, at</p>"#,
)
r#"<p><a class="detached" title="" href="/node/Node">Node</a>, at</p>"#
);
}
@ -215,10 +204,7 @@ mod tests {
fn needless_three_pipe_anchor() {
assert_eq!(
read("|Node|Destination|"),
concat!(
r#"<p><a class="detached" title="" "#,
r#"href="/node/Destination">Node</a></p>"#
)
r#"<p><a class="detached" title="" href="/node/Destination">Node</a></p>"#
);
}
@ -226,10 +212,7 @@ mod tests {
fn nonleading_second_pipe() {
assert_eq!(
read("Go to Node|Destination|, here"),
concat!(
r#"<p>Go to <a class="detached" title="" "#,
r#"href="/node/Destination">Node</a>, here</p>"#
),
r#"<p>Go to <a class="detached" title="" href="/node/Destination">Node</a>, here</p>"#,
);
}
@ -237,11 +220,7 @@ mod tests {
fn anchor_to_node_s() {
assert_eq!(
read("The |letter s|s|'s node: |s|!"),
concat!(
r#"<p>The <a class="detached" title="" "#,
r#"href="/node/s">letter s</a>'s node: "#,
r#"<a class="detached" title="" href="/node/s">s</a>!</p>"#
)
r#"<p>The <a class="detached" title="" href="/node/s">letter s</a>'s node: <a class="detached" title="" href="/node/s">s</a>!</p>"#
);
}
@ -249,10 +228,7 @@ mod tests {
fn nonleading_plural_anchor() {
assert_eq!(
read("The flower|s bloomed"),
concat!(
r#"<p>The <a class="detached" title="" "#,
r#"href="/node/flower">flowers</a> bloomed</p>"#,
)
r#"<p>The <a class="detached" title="" href="/node/flower">flowers</a> bloomed</p>"#
);
}
@ -260,11 +236,7 @@ mod tests {
fn leading_plural_anchor() {
assert_eq!(
read("Interfaces are |element|s of |system|s."),
concat!(
r#"<p>Interfaces are <a class="detached" title="" "#,
r#"href="/node/element">elements</a> of <a class="detached" "#,
r#"title="" href="/node/system">systems</a>.</p>"#
)
r#"<p>Interfaces are <a class="detached" title="" href="/node/element">elements</a> of <a class="detached" title="" href="/node/system">systems</a>.</p>"#
);
}
@ -272,11 +244,7 @@ mod tests {
fn leading_multiword_anchor() {
assert_eq!(
read("interactions are |basic elements| of systems"),
concat!(
r#"<p>interactions are <a class="detached" title="""#,
r#" href="/node/basic elements">basic elements</a> "#,
r#"of systems</p>"#,
),
r#"<p>interactions are <a class="detached" title="" href="/node/basic elements">basic elements</a> of systems</p>"#
);
}
@ -284,11 +252,7 @@ mod tests {
fn explicit_end_of_destination() {
assert_eq!(
read("interactions are |basic elements|BasicElements| of systems"),
concat!(
r#"<p>interactions are <a class="detached" title="" "#,
r#"href="/node/BasicElements">basic elements</a> of "#,
r#"systems</p>"#
)
r#"<p>interactions are <a class="detached" title="" href="/node/BasicElements">basic elements</a> of systems</p>"#
);
}
@ -296,11 +260,7 @@ mod tests {
fn explicit_end_of_external_destination() {
assert_eq!(
read("this |anchor example|https://example.com| is external"),
concat!(
r#"<p>this <a class="external" title="" "#,
r#"href="https://example.com">anchor example</a> is "#,
r#"external</p>"#
)
r#"<p>this <a class="external" title="" href="https://example.com">anchor example</a> is external</p>"#
);
}
@ -316,10 +276,7 @@ mod tests {
fn external_anchor_destination_at_eoi() {
assert_eq!(
read("a b|https://example.com"),
concat!(
r#"<p>a <a class="external" title="" "#,
r#"href="https://example.com">b</a></p>"#,
)
r#"<p>a <a class="external" title="" href="https://example.com">b</a></p>"#
);
}
@ -327,10 +284,7 @@ mod tests {
fn nonleading_plural_anchor_at_eoi() {
assert_eq!(
read("element|s"),
concat!(
r#"<p><a class="detached" title="" "#,
r#"href="/node/element">elements</a></p>"#,
)
r#"<p><a class="detached" title="" href="/node/element">elements</a></p>"#
);
}
@ -338,37 +292,17 @@ mod tests {
fn leading_plural_anchor_at_eoi() {
assert_eq!(
read("|element|s"),
concat!(
r#"<p><a class="detached" title="" "#,
r#"href="/node/element">elements</a></p>"#,
)
);
}
#[test]
fn absolute_anchor() {
let parse_result =
parser::rich_read("see the |raw endpoints|/data|.", &Graph::load());
println!("Parsed tokens: {:#?}", parse_result.tokens);
assert_eq!(
parse_result.text.unwrap(),
concat!(
r#"<p>see the <a class="absolute" title="" "#,
r#"href="/data">"#,
r#"raw endpoints</a>.</p>"#,
),
r#"<p><a class="detached" title="" href="/node/element">elements</a></p>"#
);
}
#[test]
fn http_external_anchor() {
assert_eq!(
read("a |false dichotomy|https://wikipedia.org/False_dilemma|."),
concat!(
r#"<p>a <a class="external" title="" "#,
r#"href="https://wikipedia.org/False_dilemma">"#,
r#"false dichotomy</a>.</p>"#,
read(
"a |false dichotomy|https://en.wikipedia.org/wiki/False_dilemma|."
),
r#"<p>a <a class="external" title="" href="https://en.wikipedia.org/wiki/False_dilemma">false dichotomy</a>.</p>"#
);
}
@ -381,8 +315,7 @@ mod tests {
"at rustup.rs",
)),
concat!(
r#"<p><a class="external" title="" "#,
r#"href="https://rustup.rs/">Rust toolchain</a>"#,
r#"<p><a class="external" title="" href="https://rustup.rs/">Rust toolchain</a>"#,
"\n",
"at rustup.rs</p>",
)
@ -393,11 +326,7 @@ mod tests {
fn http_external_anchor_leading_no_third_then_space() {
assert_eq!(
read("|Rust toolchain|https://rustup.rs/ at rustup.rs"),
concat!(
r#"<p><a class="external" title="" "#,
r#"href="https://rustup.rs/">Rust toolchain</a> "#,
r#"at rustup.rs</p>"#,
),
r#"<p><a class="external" title="" href="https://rustup.rs/">Rust toolchain</a> at rustup.rs</p>"#
);
}
@ -405,10 +334,7 @@ mod tests {
fn http_external_anchor_leading_no_third_then_eoi() {
assert_eq!(
read("|Rust toolchain|https://rustup.rs/"),
concat!(
r#"<p><a class="external" title="" "#,
r#"href="https://rustup.rs/">Rust toolchain</a></p>"#,
)
r#"<p><a class="external" title="" href="https://rustup.rs/">Rust toolchain</a></p>"#
);
}
@ -418,10 +344,7 @@ mod tests {
read("\n|SomeAnchor|\n"),
concat!(
"\n",
concat!(
r#"<p><a class="detached" title="" "#,
r#"href="/node/SomeAnchor">SomeAnchor</a></p>"#,
)
r#"<p><a class="detached" title="" href="/node/SomeAnchor">SomeAnchor</a></p>"#
),
);
}
@ -431,11 +354,9 @@ mod tests {
assert_eq!(
read("|SomeAnchor|\n|SomeOtherAnchor|\n"),
concat!(
r#"<p><a class="detached" title="" "#,
r#"href="/node/SomeAnchor">SomeAnchor</a>"#,
r#"<p><a class="detached" title="" href="/node/SomeAnchor">SomeAnchor</a>"#,
"\n",
r#"<a class="detached" title="" "#,
r#"href="/node/SomeOtherAnchor">SomeOtherAnchor</a></p>"#,
r#"<a class="detached" title="" href="/node/SomeOtherAnchor">SomeOtherAnchor</a></p>"#
)
);
}
@ -445,12 +366,10 @@ mod tests {
assert_eq!(
read("|SomeAnchor|\n\n|SomeOtherAnchor|\n"),
concat!(
r#"<p><a class="detached" title="" "#,
r#"href="/node/SomeAnchor">SomeAnchor</a></p>"#,
r#"<p><a class="detached" title="" href="/node/SomeAnchor">SomeAnchor</a></p>"#,
"\n",
"\n",
r#"<p><a class="detached" title="" "#,
r#"href="/node/SomeOtherAnchor">SomeOtherAnchor</a></p>"#,
r#"<p><a class="detached" title="" href="/node/SomeOtherAnchor">SomeOtherAnchor</a></p>"#
),
);
}
@ -459,10 +378,7 @@ mod tests {
fn trailing_anchor() {
assert_eq!(
read("see acks|acks"),
concat!(
r#"<p>see <a class="detached" title="" "#,
r#"href="/node/acks">acks</a></p>"#,
)
r#"<p>see <a class="detached" title="" href="/node/acks">acks</a></p>"#
);
}
@ -472,9 +388,8 @@ mod tests {
read("\nsee acks|acks\n"),
concat!(
"\n",
r#"<p>see <a class="detached" title="" "#,
r#"href="/node/acks">acks</a></p>"#,
),
r#"<p>see <a class="detached" title="" href="/node/acks">acks</a></p>"#
)
);
}
@ -502,10 +417,7 @@ mod tests {
fn anchor_with_trailing_single_quote() {
assert_eq!(
read("the |lion|'s mouth"),
concat!(
r#"<p>the <a class="detached" title="" "#,
r#"href="/node/lion">lion</a>'s mouth</p>"#,
)
r#"<p>the <a class="detached" title="" href="/node/lion">lion</a>'s mouth</p>"#,
);
}
@ -513,10 +425,7 @@ mod tests {
fn anchor_with_trailing_double_quote() {
assert_eq!(
read(r#"the "|real|" motive"#),
concat!(
r#"<p>the "<a class="detached" title="" "#,
r#"href="/node/real">real</a>" motive</p>"#,
)
r#"<p>the "<a class="detached" title="" href="/node/real">real</a>" motive</p>"#,
);
}
@ -524,10 +433,7 @@ mod tests {
fn anchor_with_trailing_parenthesis() {
assert_eq!(
read("this (though |true|) was questioned"),
concat!(
r#"<p>this (though <a class="detached" title="" "#,
r#"href="/node/true">true</a>) was questioned</p>"#,
)
r#"<p>this (though <a class="detached" title="" href="/node/true">true</a>) was questioned</p>"#,
);
}
@ -535,10 +441,7 @@ mod tests {
fn anchor_with_leading_single_quote() {
assert_eq!(
read("the 'real|Reality' motive"),
concat!(
r#"<p>the '<a class="detached" title="" "#,
r#"href="/node/Reality">real</a>' motive</p>"#,
)
r#"<p>the '<a class="detached" title="" href="/node/Reality">real</a>' motive</p>"#,
);
}
@ -546,10 +449,7 @@ mod tests {
fn anchor_with_leading_double_quote() {
assert_eq!(
read(r#"the "real|Reality" motive"#),
concat!(
r#"<p>the "<a class="detached" title="" "#,
r#"href="/node/Reality">real</a>" motive</p>"#,
)
r#"<p>the "<a class="detached" title="" href="/node/Reality">real</a>" motive</p>"#,
);
}
@ -557,10 +457,7 @@ mod tests {
fn anchor_with_leading_parenthesis() {
assert_eq!(
read("her (last|Surname) name"),
concat!(
r#"<p>her (<a class="detached" title="" "#,
r#"href="/node/Surname">last</a>) name</p>"#,
)
r#"<p>her (<a class="detached" title="" href="/node/Surname">last</a>) name</p>"#,
);
}
@ -568,10 +465,7 @@ mod tests {
fn anchor_with_internal_apostrophe() {
assert_eq!(
read("the |lion's mouth|album was released"),
concat!(
r#"<p>the <a class="detached" title="" "#,
r#"href="/node/album">lion's mouth</a> was released</p>"#,
)
r#"<p>the <a class="detached" title="" href="/node/album">lion's mouth</a> was released</p>"#
);
}
@ -579,10 +473,7 @@ mod tests {
fn nonleading_anchor_with_internal_apostrophe() {
assert_eq!(
read("they decided to stay at Jane's|YellowHouse that night"),
concat!(
r#"<p>they decided to stay at <a class="detached" title="" "#,
r#"href="/node/YellowHouse">Jane's</a> that night</p>"#,
)
r#"<p>they decided to stay at <a class="detached" title="" href="/node/YellowHouse">Jane's</a> that night</p>"#
);
}
@ -590,10 +481,7 @@ mod tests {
fn nonleading_anchor_with_internal_apostrophe_at_eoi() {
assert_eq!(
read("they decided to stay at Jane's|YellowHouse"),
concat!(
r#"<p>they decided to stay at <a class="detached" "#,
r#"title="" href="/node/YellowHouse">Jane's</a></p>"#,
)
r#"<p>they decided to stay at <a class="detached" title="" href="/node/YellowHouse">Jane's</a></p>"#
);
}
@ -601,10 +489,7 @@ mod tests {
fn nonleading_anchor_with_internal_apostrophe_at_soi() {
assert_eq!(
read("Jane's|YellowHouse that night"),
concat!(
r#"<p><a class="detached" title="" "#,
r#"href="/node/YellowHouse">Jane's</a> that night</p>"#,
)
r#"<p><a class="detached" title="" href="/node/YellowHouse">Jane's</a> that night</p>"#
);
}
@ -612,10 +497,7 @@ mod tests {
fn anchor_with_internal_double_quotes() {
assert_eq!(
read(r#"the |"real"|Truth motive"#),
concat!(
r#"<p>the <a class="detached" title="" "#,
r#"href="/node/Truth">"real"</a> motive</p>"#,
)
r#"<p>the <a class="detached" title="" href="/node/Truth">"real"</a> motive</p>"#,
);
}
@ -623,10 +505,7 @@ mod tests {
fn anchor_with_internal_double_quotes_wrapping_spaced_words() {
assert_eq!(
read(r#"the |"bare reality"|Ideology they believed"#),
concat!(
r#"<p>the <a class="detached" title="" "#,
r#"href="/node/Ideology">"bare reality"</a> they believed</p>"#,
)
r#"<p>the <a class="detached" title="" href="/node/Ideology">"bare reality"</a> they believed</p>"#,
);
}
@ -634,10 +513,7 @@ mod tests {
fn anchor_with_internal_parenthesis() {
assert_eq!(
read("her |last (name)|Surname was Amad"),
concat!(
r#"<p>her <a class="detached" title="" "#,
r#"href="/node/Surname">last (name)</a> was Amad</p>"#,
)
r#"<p>her <a class="detached" title="" href="/node/Surname">last (name)</a> was Amad</p>"#,
);
}
@ -645,11 +521,7 @@ mod tests {
fn anchor_with_internal_parenthesis_wrapping_spaced_words() {
assert_eq!(
read("this |truth (though questionable) was fine|Absurd to them "),
concat!(
r#"<p>this <a class="detached" title="" "#,
r#"href="/node/Absurd">truth (though questionable) was "#,
r#"fine</a> to them</p>"#,
)
r#"<p>this <a class="detached" title="" href="/node/Absurd">truth (though questionable) was fine</a> to them</p>"#
);
}
}

87
src/syntax/content/parser/context/block.rs
View file

@ -1,22 +1,17 @@
use std::{iter::Peekable, slice::Iter};
use crate::{
graph::Graph,
prelude::*,
syntax::content::{
Parseable as _,
parser::{
Block, Lexeme, State, Token, context,
token::{
Header, LineBreak, List, Paragraph, PreFormat, Quote, Table,
Verse,
},
Block, Token, Lexeme, State,
token::{Header, List, Literal, Paragraph, PreFormat},
},
},
graph::Graph,
};
/// A return of `true` will trigger a `continue` on the outer parser, causing
/// no more subsequent parsing of the current lexeme.
pub fn parse(
lexeme: &Lexeme,
state: &mut State,
@ -29,7 +24,8 @@ pub fn parse(
if PreFormat::probe(lexeme) {
log!(VERBOSE, "Block Context: None -> PreFormat on {lexeme}");
state.context.block = Block::PreFormat;
return true
tokens.push(Token::PreFormat(PreFormat::new(true)));
return true;
} else if Header::probe(lexeme) {
let mut header = Header::lex(lexeme);
header.dom_id = Some(Header::make_id(
@ -45,26 +41,9 @@ pub fn parse(
log!(VERBOSE, "Block Context: None -> List on {lexeme}");
state.context.block = Block::List;
state.buffers.list.candidate.ordered = lexeme.match_char('+');
return context::list::parse(
return super::list::parse(
lexeme, state, tokens, iterator, graph,
);
} else if Quote::probe(lexeme) {
log!(VERBOSE, "Block Context: None -> Quote on {lexeme}");
state.context.block = Block::Quote;
iterator.next();
return true;
} else if Verse::probe(lexeme) {
log!(VERBOSE, "Block Context: None -> Verse on {lexeme}");
state.context.block = Block::Verse;
tokens.push(Token::Verse(Verse::new(true)));
iterator.next();
iterator.next();
return true;
} else if Table::probe(lexeme) {
log!(VERBOSE, "Block Context: None -> Table on {lexeme}");
state.context.block = Block::Table;
iterator.next();
return true;
} else if Paragraph::probe(lexeme) {
log!(VERBOSE, "Block Context: None -> Paragraph on {lexeme}");
state.context.block = Block::Paragraph;
@ -72,7 +51,14 @@ pub fn parse(
}
},
Block::PreFormat => {
return context::preformat::parse(lexeme, state, tokens, iterator);
if PreFormat::probe(lexeme) {
tokens.push(Token::PreFormat(PreFormat::new(false)));
log!(VERBOSE, "Block Context: PreFormat -> None on {lexeme}");
state.context.block = Block::None;
} else {
tokens.push(Token::Literal(Literal::lex(lexeme)));
}
return true;
},
Block::Paragraph => {
if Paragraph::probe_end(lexeme) {
@ -89,30 +75,7 @@ pub fn parse(
}
},
Block::List => {
return context::list::parse(lexeme, state, tokens, iterator, graph);
},
Block::Quote => {
return context::quote::parse(
lexeme, state, tokens, iterator, graph,
);
},
Block::Table => {
return context::table::parse(
lexeme, state, tokens, iterator, graph,
);
},
Block::Verse => {
if Verse::probe_end(lexeme) {
tokens.push(Token::Verse(Verse::new(false)));
log!(VERBOSE, "Block Context: Verse -> None on {lexeme}");
state.context.block = Block::None;
iterator.next();
iterator.next();
return true;
} else if lexeme.match_char('\n') {
tokens.push(Token::LineBreak(LineBreak));
return true;
}
return super::list::parse(lexeme, state, tokens, iterator, graph);
},
}
false
@ -122,14 +85,16 @@ pub fn parse(
mod tests {
use crate::{
graph::Graph,
syntax::content::parser::{
self, Block, State, Token, context,
token::{Header, header::Level},
self, Block, Token, context, State,
token::{Header, header::Level, PreFormat},
},
graph::Graph,
};
fn read(input: &str) -> String { parser::read(input, &Graph::default()) }
fn read(input: &str) -> String {
parser::read(input, &Graph::default())
}
#[test]
fn pre() {
@ -159,6 +124,16 @@ mod tests {
assert_eq!(vec, vec![Token::Header(Header::from_u8(1, false, None))]);
}
#[test]
fn end_with_open_preformat() {
let mut state = State::default();
state.context.block = Block::PreFormat;
let mut vec: Vec<Token> = vec![];
context::close(&state, &mut vec);
assert_eq!(vec, vec![Token::PreFormat(PreFormat::new(false))]);
}
#[test]
fn truncated_header_level() {
let u: usize = 999;

8
src/syntax/content/parser/context/inline.rs
View file

@ -1,16 +1,17 @@
use std::{iter::Peekable, slice::Iter};
use crate::{
graph::Graph,
prelude::*,
syntax::content::{
Parseable as _,
parser::{
Inline, Lexeme, State, Token, context,
Lexeme, State,
state::AnchorBuffer,
Inline, context, Token,
token::{Anchor, Code, Literal},
},
},
graph::Graph,
};
pub fn parse(
@ -48,10 +49,11 @@ pub fn parse(
log!(VERBOSE, "Inline Context: Code -> None on {lexeme}");
state.context.inline = Inline::None;
tokens.push(Token::Code(Code::new(false)));
return true;
} else {
tokens.push(Token::Literal(Literal::lex(lexeme)));
}
return true;
}
},
Inline::Anchor => {
if context::anchor::parse(lexeme, state, tokens, graph) {

19
src/syntax/content/parser/context/list.rs
View file

@ -1,11 +1,11 @@
use std::{iter::Peekable, slice::Iter};
use crate::{
graph::Graph,
prelude::*,
syntax::content::parser::{
Lexeme, State, Token, context::Block, format, state, token::Item,
context::Block, Token, Lexeme, State, state, token::Item, format,
},
graph::Graph,
};
/// Handles open list contexts until a list is fully parsed.
@ -13,9 +13,6 @@ use crate::{
/// A return of `true` will trigger a continue in the outer parser,
/// skipping any further parsing of the current lexeme.
///
/// Performs checked arithmetic to the following effect:
/// - The indent of list items will saturate at `u8::MAX` (255) spaces.
///
/// # Panics
/// This parser can handle only the List context, and will panic if passed an
/// unrelated context since it has no knowledge on how to handle them.
@ -30,7 +27,6 @@ pub fn parse(
let candidate = &mut buffer.candidate;
let item_candidate = &mut buffer.item_candidate;
#[expect(clippy::wildcard_enum_match_arm)]
match state.context.block {
Block::List => {
if lexeme.match_char(' ') && item_candidate.depth.is_none() {
@ -78,7 +74,10 @@ pub fn parse(
item_candidate.text.push_str(&lexeme.text());
}
},
_ => {
Block::None
| Block::Paragraph
| Block::Header(_)
| Block::PreFormat => {
panic!("List context parser called to handle non-list context")
},
}
@ -88,11 +87,13 @@ pub fn parse(
#[cfg(test)]
mod tests {
use crate::{
syntax::content::parser::{self, context::list::parse, Lexeme, State},
graph::Graph,
syntax::content::parser::{self, Lexeme, State, context::list::parse},
};
fn read(input: &str) -> String { parser::read(input, &Graph::default()) }
fn read(input: &str) -> String {
parser::read(input, &Graph::default())
}
#[test]
fn unordered_list() {

61
src/syntax/content/parser/context/preformat.rs
View file

@ -1,61 +0,0 @@
use std::{iter::Peekable, slice::Iter};
use crate::{
prelude::*,
syntax::content::{
Parseable as _,
parser::{Lexeme, State, Token, context::Block, token::PreFormat},
},
};
/// Handles open `PreFormat` contexts until a block is fully parsed.
///
/// A return of `true` will trigger a continue in the outer parser,
/// skipping any further parsing of the current lexeme.
///
/// # Panics
/// This parser can handle only the List context, and will panic if passed an
/// unrelated context since it has no knowledge on how to handle them.
pub fn parse(
lexeme: &Lexeme,
state: &mut State,
tokens: &mut Vec<Token>,
iterator: &mut Peekable<Iter<'_, Lexeme>>,
) -> bool {
let buffer = &mut state.buffers.preformat;
let candidate = &mut buffer.candidate;
#[expect(clippy::wildcard_enum_match_arm)]
match state.context.block {
Block::PreFormat => {
if lexeme.match_first_char('<') {
candidate.text.push_str("&lt;");
candidate.text.push_str(
lexeme.text().strip_prefix('<').unwrap_or(&lexeme.text()),
);
} else if lexeme.match_last_char('>') {
candidate.text.push_str(
lexeme.text().strip_suffix('>').unwrap_or(&lexeme.text()),
);
candidate.text.push_str("&gt;");
} else if lexeme.match_char('\\') {
candidate.text.push_str(lexeme.next().as_str());
iterator.next();
return true;
} else if PreFormat::probe(lexeme) {
// found end of block, push it and reset state
log!(VERBOSE, "Accepting preformat candidate {candidate}");
tokens.push(Token::PreFormat(candidate.clone()));
state.context.block = Block::None;
*candidate = PreFormat::default();
} else {
// anything else is pushed into the candidate preformat's text
candidate.text.push_str(&lexeme.text());
}
},
_ => {
panic!("PreFormat context parser called for {:?}", state.context)
},
}
true
}

92
src/syntax/content/parser/context/quote.rs
View file

@ -1,92 +0,0 @@
use std::{iter::Peekable, slice::Iter};
use crate::{
graph::Graph,
prelude::*,
syntax::content::parser::{
Lexeme, State, Token, context::Block, format, state, token::Quote,
},
};
/// Handles open quote contexts until a quote is fully parsed.
///
/// A return of `true` will trigger a continue in the outer parser,
/// skipping any further parsing of the current lexeme.
///
/// # Panics
/// This parser can handle only the Quote context, and will panic if passed an
/// unrelated context since it has no knowledge on how to handle them.
pub fn parse(
lexeme: &Lexeme,
state: &mut State,
tokens: &mut Vec<Token>,
iterator: &mut Peekable<Iter<'_, Lexeme>>,
graph: &Graph,
) -> bool {
let buffer = &mut state.buffers.quote;
let candidate = &mut buffer.candidate;
#[expect(clippy::wildcard_enum_match_arm)]
match state.context.block {
Block::Quote => {
if Quote::probe_end(lexeme) {
log!(VERBOSE, "Probed end of quote on {lexeme}");
let (text, text_tokens) = format(&candidate.text, graph);
candidate.text = text;
state.format_tokens.extend_from_slice(&text_tokens);
if let Some(citation) = &candidate.citation {
let (formatted_citation, citation_tokens) =
format(citation, graph);
candidate.citation = Some(formatted_citation);
state.format_tokens.extend_from_slice(&citation_tokens);
if let Some(url) = citation_tokens.into_iter().find_map(
|token| match token {
Token::Anchor(a) if a.external() => a.destination(),
_ => None,
},
) {
candidate.url = Some(url);
}
}
tokens.push(Token::Quote(candidate.clone()));
log!(VERBOSE, "Block Context: Quote -> None on {lexeme}");
state.context.block = Block::None;
*buffer = state::QuoteBuffer::default();
} else if !buffer.in_citation
&& lexeme.match_char('\n')
&& lexeme.next() == "--"
{
log!(VERBOSE, "Matched citation start on {lexeme}");
buffer.in_citation = true;
iterator.next();
iterator.next();
} else if lexeme.match_char_sequence('\n', '>') {
log!(VERBOSE, "Matched break-aware sequence on {lexeme}");
candidate.text.push_str(" <\n");
iterator.next();
} else {
log!(VERBOSE, "Entered quote else branch on {lexeme}");
if buffer.in_citation {
log!(VERBOSE, "Extending citation on {lexeme}");
candidate.extend_citation(&lexeme.text());
if lexeme.match_char('\n') && lexeme.next() == "--" {
candidate.text.push('\n');
iterator.next();
} else if lexeme.match_char('\n') {
buffer.in_citation = false;
}
} else {
log!(VERBOSE, "Extending quote on {lexeme}");
candidate.text.push_str(&lexeme.text());
}
}
},
_ => {
panic!("Quote context parser called to handle non-quote context")
},
}
true
}

447
src/syntax/content/parser/context/table.rs
View file

@ -1,447 +0,0 @@
use std::{iter::Peekable, slice::Iter};
use crate::{
graph::Graph,
prelude::*,
syntax::content::parser::{
Lexeme, State, Token, context::Block, format, state, token::Table,
},
};
/// Handles open table contexts until a table is fully parsed.
///
/// A return of `true` will trigger a continue in the outer parser,
/// skipping any further parsing of the current lexeme.
///
/// # Panics
/// This parser can handle only the Table context, and will panic if passed an
/// unrelated context since it has no knowledge on how to handle them.
pub fn parse(
lexeme: &Lexeme,
state: &mut State,
tokens: &mut Vec<Token>,
iterator: &mut Peekable<Iter<'_, Lexeme>>,
graph: &Graph,
) -> bool {
let buffer = &mut state.buffers.table;
let candidate = &mut buffer.candidate;
let mut parse_text = |text: &str| {
let (parsed_text, text_tokens) = format(text, graph);
state.format_tokens.extend_from_slice(&text_tokens);
parsed_text
};
#[expect(clippy::wildcard_enum_match_arm)]
match state.context.block {
Block::Table => {
if Table::probe_end(lexeme) {
log!(VERBOSE, "Probed end of table on {lexeme}");
if buffer.in_header {
log!(VERBOSE, "Adding unterminated header: {lexeme}");
candidate.add_header(&parse_text(&buffer.cell));
} else {
let descriptor = if buffer.in_cell {
"unterminated"
} else {
"undelimited"
};
log!(VERBOSE, "Adding {descriptor} cell: {lexeme}");
candidate.add_cell(&parse_text(&buffer.cell));
}
tokens.push(Token::Table(candidate.clone()));
log!(VERBOSE, "Block Context: Table -> None on {lexeme}");
state.context.block = Block::None;
*buffer = state::TableBuffer::default();
iterator.next();
} else if lexeme.match_char('\n')
|| lexeme.match_char_triple(' ', '!', '\n')
|| lexeme.match_char_triple(' ', '|', '\n')
{
log!(VERBOSE, "Adding row: found newline on {lexeme}");
if !buffer.cell.is_empty() {
if buffer.in_header {
log!(VERBOSE, "Adding unterminated header: {lexeme}");
candidate.add_header(&parse_text(&buffer.cell));
} else {
let descriptor = if buffer.in_cell {
"unterminated"
} else {
"undelimited"
};
log!(VERBOSE, "Adding {descriptor} cell: {lexeme}");
candidate.add_cell(&parse_text(&buffer.cell));
}
buffer.cell.clear();
}
if lexeme.match_next_either_char('|', '!') {
iterator.next();
}
buffer.in_header = false;
buffer.in_cell = false;
candidate.add_row(vec![]);
} else if lexeme.match_char_triple(' ', '!', ' ') {
buffer.in_header = true;
if !buffer.cell.trim().is_empty() {
log!(VERBOSE, "Adding header: found spaced ! on {lexeme}");
candidate.add_header(&parse_text(&buffer.cell));
buffer.cell.clear();
}
iterator.next();
iterator.next();
} else if lexeme.match_char_triple(' ', '|', ' ') {
buffer.in_cell = true;
if !buffer.cell.trim().is_empty() {
log!(VERBOSE, "Adding cell: found spaced | on {lexeme}");
candidate.add_cell(&parse_text(&buffer.cell));
buffer.cell.clear();
}
iterator.next();
iterator.next();
} else {
log!(VERBOSE, "Extending cell text on {lexeme}");
buffer.cell.push_str(lexeme.text().as_str());
}
},
_ => {
panic!("Table context parser called to handle non-table context")
},
}
true
}
#[cfg(test)]
mod tests {
use crate::{graph::Graph, syntax::content::parser};
fn read(input: &str) -> String { parser::read(input, &Graph::default()) }
fn read_loaded(input: &str) -> String {
parser::read(input, &Graph::load())
}
#[test]
fn single_row() {
assert_eq!(
read(concat!("%", "\n", "a | b | c", "\n", "%", "\n")),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <td>a</td>", "\n",
" <td>b</td>", "\n",
" <td>c</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn two_rows() {
assert_eq!(
read(concat!(
"%", "\n",
"a | b | c", "\n",
"d | e | f", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <td>a</td>", "\n",
" <td>b</td>", "\n",
" <td>c</td>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>d</td>", "\n",
" <td>e</td>", "\n",
" <td>f</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn three_rows() {
assert_eq!(
read(concat!(
"%", "\n",
"a | b | c", "\n",
"d | e | f", "\n",
"g | h | i", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <td>a</td>", "\n",
" <td>b</td>", "\n",
" <td>c</td>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>d</td>", "\n",
" <td>e</td>", "\n",
" <td>f</td>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>g</td>", "\n",
" <td>h</td>", "\n",
" <td>i</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn with_header() {
assert_eq!(
read(concat!(
"%", "\n",
"hA ! hB ! hC", "\n",
"a | b | c", "\n",
"d | e | f", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <th>hA</th>", "\n",
" <th>hB</th>", "\n",
" <th>hC</th>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>a</td>", "\n",
" <td>b</td>", "\n",
" <td>c</td>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>d</td>", "\n",
" <td>e</td>", "\n",
" <td>f</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn with_anchor() {
assert_eq!(
read(concat!(
"%", "\n",
"a | |Node| | c", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <td>a</td>", "\n",
r#" <td><a class="detached" title="" "#,
r#"href="/node/Node">Node</a></td>"#, "\n",
" <td>c</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn with_loaded_anchor() {
assert_eq!(
read_loaded(concat!(
"%", "\n",
"a | |Node| | c", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <td>a</td>", "\n",
r#" <td><a class="attached" title="A node is defined "#,
r#"in your graph file starting with a table header of the "#,
r#"form:" href="/node/Node">Node</a></td>"#, "\n",
" <td>c</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn no_leading_delimiters() {
assert_eq!(
read_loaded(concat!(
"%", "\n",
"a ! b ! c !", "\n",
"d | e | f |", "\n",
"g | h | i |", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <th>a</th>", "\n",
" <th>b</th>", "\n",
" <th>c</th>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>d</td>", "\n",
" <td>e</td>", "\n",
" <td>f</td>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>g</td>", "\n",
" <td>h</td>", "\n",
" <td>i</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn no_trailing_delimiters() {
assert_eq!(
read_loaded(concat!(
"%", "\n",
" ! a ! b ! c", "\n",
" | d | e | f", "\n",
" | g | h | i", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <th>a</th>", "\n",
" <th>b</th>", "\n",
" <th>c</th>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>d</td>", "\n",
" <td>e</td>", "\n",
" <td>f</td>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>g</td>", "\n",
" <td>h</td>", "\n",
" <td>i</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn with_leading_and_trailing_delimiters() {
assert_eq!(
read_loaded(concat!(
"%", "\n",
" ! a ! b ! c !", "\n",
" | d | e | f |", "\n",
" | g | h | i |", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <th>a</th>", "\n",
" <th>b</th>", "\n",
" <th>c</th>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>d</td>", "\n",
" <td>e</td>", "\n",
" <td>f</td>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>g</td>", "\n",
" <td>h</td>", "\n",
" <td>i</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn no_flanking_delimiters() {
assert_eq!(
read_loaded(concat!(
"%", "\n",
"a ! b ! c", "\n",
"d | e | f", "\n",
"g | h | i", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <th>a</th>", "\n",
" <th>b</th>", "\n",
" <th>c</th>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>d</td>", "\n",
" <td>e</td>", "\n",
" <td>f</td>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>g</td>", "\n",
" <td>h</td>", "\n",
" <td>i</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
#[test]
fn with_indent() {
assert_eq!(
read_loaded(concat!(
"%", "\n",
" ! a ! b ! c !", "\n",
" | d | e | f |", "\n",
" | g | h | i |", "\n",
"%", "\n",
)),
concat!(
"\n",
"<table>", "\n",
" <tr>", "\n",
" <th>a</th>", "\n",
" <th>b</th>", "\n",
" <th>c</th>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>d</td>", "\n",
" <td>e</td>", "\n",
" <td>f</td>", "\n",
" </tr>", "\n",
" <tr>", "\n",
" <td>g</td>", "\n",
" <td>h</td>", "\n",
" <td>i</td>", "\n",
" </tr>", "\n",
"</table>", "\n",
)
);
}
}

41
src/syntax/content/parser/lexeme.rs
View file

@ -1,6 +1,6 @@
use std::fmt;
use crate::syntax::content::parser::segment::delimiter::Delimiters;
use crate::{syntax::content::parser::segment::delimiter::Delimiters};
#[derive(Clone, Debug, Default)]
pub struct Lexeme {
@ -22,18 +22,26 @@ impl Lexeme {
}
}
pub fn text(&self) -> String { self.text.clone() }
pub fn text(&self) -> String {
self.text.clone()
}
pub fn next(&self) -> String { self.next.clone() }
pub fn next(&self) -> String {
self.next.clone()
}
pub const fn last(&self) -> bool { self.last }
pub fn last(&self) -> bool {
self.last
}
pub const fn first(&self) -> bool { self.first }
pub fn first(&self) -> bool {
self.first
}
pub fn mutate_text(&mut self, new: &str) { self.text = new.to_string(); }
pub fn mutate_text(&mut self, new: &str) {
self.text = new.to_string();
}
/// Returns an Option containing the character if the raw lexeme text
/// is composed of a single character, None if it has multiple characters.
pub fn as_char(&self) -> Option<char> {
if self.text.chars().count() == 1 {
self.text.chars().nth(0)
@ -58,7 +66,6 @@ impl Lexeme {
}
}
/// Returns true if the raw lexeme text is a single matching character.
pub fn match_char(&self, c: char) -> bool {
self.as_char().is_some_and(|as_char| as_char == c)
}
@ -89,8 +96,6 @@ impl Lexeme {
&& self.match_third_char(c3)
}
/// Returns true if the lexeme raw text is composed of a single character
/// and this character is in the provided slice.
pub fn match_char_in(&self, slice: &[char]) -> bool {
self.as_char().is_some_and(|c| slice.contains(&c))
}
@ -136,7 +141,9 @@ impl Lexeme {
.is_some_and(|c| delimiters.is_delimiter(c))
}
pub fn next_first_char(&self) -> Option<char> { self.next.chars().nth(0) }
pub fn next_first_char(&self) -> Option<char> {
self.next.chars().nth(0)
}
pub fn match_first_char(&self, query: char) -> bool {
self.text.chars().nth(0).is_some_and(|c| c == query)
@ -151,7 +158,7 @@ impl Lexeme {
}
/// # Panics
/// Panics if number of chars for a single lexeme exceeds `i32::MAX`.
/// Panics if number of chars for a single lexeme exceeds `i32::MAX`
pub fn count_char(&self, c: char) -> i32 {
let count = self.text().chars().filter(|&n| n == c).count();
match i32::try_from(count) {
@ -229,7 +236,7 @@ impl Lexeme {
impl fmt::Display for Lexeme {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
use crate::dev::log::wrap;
use crate::log::wrap;
let properties = if self.last && self.first {
"[S] "
@ -291,7 +298,7 @@ mod tests {
fn first_segment() {
let payload = "nhNc fGev QnGW E4hj ExyZ";
let lexeme = Lexeme::new(payload, "", "");
assert_eq!(lexeme.first_segment(), Some(String::from("nhNc")));
assert_eq!(lexeme.clone().first_segment(), Some(String::from("nhNc")));
}
#[test]
@ -386,8 +393,8 @@ mod tests {
let lexemes = Lexeme::collect(&input);
let first = lexemes.first().unwrap();
let second = &lexemes[1];
let third = &lexemes[2];
let second = lexemes.get(1).unwrap();
let third = lexemes.get(2).unwrap();
let last = lexemes.last().unwrap();
assert_eq!(

93
src/syntax/content/parser/lexer.rs
View file

@ -1,93 +0,0 @@
use crate::{
graph::Graph,
prelude::*,
syntax::content::{
LexMap, Parseable as _, TokenOutput,
parser::{
context,
lexeme::Lexeme,
point, segment,
state::State,
token::{LineBreak, Literal, Token},
},
},
};
pub(super) const LEXMAP: LexMap = &[
(LineBreak::probe, |lexeme| {
Token::LineBreak(LineBreak::lex(lexeme))
}),
(Literal::probe, |lexeme| {
Token::Literal(Literal::lex(lexeme))
}),
];
pub(super) fn lex(
text: &str,
map: LexMap,
graph: &Graph,
blocking: bool,
) -> TokenOutput {
let mut tokens: Vec<Token> = Vec::default();
let mut state = State::default();
let segments = segment::segment(text);
let lexemes = Lexeme::collect(&segments);
log!(VERBOSE, "Segments: {segments:?}");
let mut iterator = lexemes.iter().peekable();
while let Some(lexeme) = iterator.next() {
if lexeme.match_char('\\')
&& !matches!(state.context.block, context::Block::PreFormat)
{
if let Some(next) = iterator.next() {
tokens.push(Token::Literal(Literal::lex(next)));
}
continue;
}
if blocking {
if context::block::parse(
lexeme,
&mut state,
&mut tokens,
&mut iterator,
graph,
) {
continue;
}
}
if point::parse(lexeme, &mut state, &mut tokens, &mut iterator) {
continue;
}
if context::inline::parse(
lexeme,
&mut state,
&mut tokens,
&mut iterator,
graph,
) {
continue;
}
for (probe, lex) in map {
if probe(lexeme) {
let token = lex(lexeme);
log!(VERBOSE, "Lexmap lexed {lexeme} into {token}");
tokens.push(token);
break;
}
}
}
context::close(&state, &mut tokens);
TokenOutput {
tokens,
format_tokens: state.format_tokens,
text: None,
}
}

32
src/syntax/content/parser/point.rs
View file

@ -17,9 +17,9 @@ pub fn parse(
tokens: &mut Vec<Token>,
iterator: &mut Peekable<Iter<'_, Lexeme>>,
) -> bool {
if matches!(state.context.block, super::context::Block::PreFormat)
|| matches!(state.context.inline, super::context::Inline::Code)
{
if let super::context::Block::PreFormat = state.context.block {
return false;
} else if let super::context::Inline::Code = state.context.inline {
return false;
}
@ -58,18 +58,17 @@ pub fn parse(
#[cfg(test)]
mod tests {
use crate::{graph::Graph, syntax::content::parser};
use crate::{syntax::content::parser, graph::Graph};
fn read(input: &str) -> String { parser::read(input, &Graph::default()) }
fn read(input: &str) -> String {
parser::read(input, &Graph::default())
}
#[test]
fn oblique_anchor() {
assert_eq!(
read("w _|S|_ w"),
concat!(
r#"<p>w <em><a class="detached" title="" "#,
r#"href="/node/S">S</a></em> w</p>"#,
)
r#"<p>w <em><a class="detached" title="" href="/node/S">S</a></em> w</p>"#
);
}
@ -77,8 +76,7 @@ mod tests {
fn oblique_anchor_with_trailing_comma() {
assert_eq!(
read("w _|S|_, w"),
concat!(r#"<p>w <em><a class="detached" title="" "#,
r#"href="/node/S">S</a></em>, w</p>"#)
r#"<p>w <em><a class="detached" title="" href="/node/S">S</a></em>, w</p>"#
);
}
@ -86,17 +84,9 @@ mod tests {
fn oblique() {
assert_eq!(
read(
"_|this anchor is oblique|o as are these literals_ but not \
these _just these_, not this _and these with an |anc80r| \
again_"
"_|this anchor is oblique|o as are these literals_ but not these _just these_, not this _and these with an |anc80r| again_"
),
concat!(
r#"<p><em><a class="detached" title="" href="/node/o">"#,
r#"this anchor is oblique</a> as are these literals</em> "#,
r#"but not these <em>just these</em>, not this <em>and these "#,
r#"with an <a class="detached" title="" "#,
r#"href="/node/anc80r">anc80r</a> again</em></p>"#,
)
r#"<p><em><a class="detached" title="" href="/node/o">this anchor is oblique</a> as are these literals</em> but not these <em>just these</em>, not this <em>and these with an <a class="detached" title="" href="/node/anc80r">anc80r</a> again</em></p>"#
);
}

13
src/syntax/content/parser/segment.rs
View file

@ -1,4 +1,6 @@
pub fn segment(text: &str) -> Vec<String> { delimiter::atomize(text) }
pub fn segment(text: &str) -> Vec<String> {
delimiter::atomize(text)
}
pub mod delimiter {
@ -144,8 +146,7 @@ pub mod delimiter {
fn atomize_flankign_sentence() {
assert_eq!(
atomize(
"about_colors: the colors _amber_, _orange_ and \
_yellow mustard_ to `jane_bishop@mail.com`."
"about_colors: the colors _amber_, _orange_ and _yellow mustard_ to `jane_bishop@mail.com`."
),
vec![
"about_colors",
@ -187,8 +188,7 @@ pub mod delimiter {
#[test]
fn atomize_words() {
let actual = atomize(
" justification for the actions of those who hold \
authority inevitably dwindles ",
" justification for the actions of those who hold authority inevitably dwindles ",
);
let expected = vec![
" ",
@ -285,8 +285,7 @@ pub mod delimiter {
#[test]
fn atomize_pipes_and_ticks() {
let actual = atomize(
"every other |time| as `it could or |perhaps somehow|then or \
now| it was` perceived",
"every other |time| as `it could or |perhaps somehow|then or now| it was` perceived",
);
let expected = vec![
"every",

76
src/syntax/content/parser/state.rs
View file

@ -2,11 +2,11 @@ use std::collections::HashMap;
use crate::syntax::content::parser::{
Token,
context::Context,
token::{Anchor, Item, List, PreFormat, Quote, Table},
context::{Block, Context, Inline},
token::{Anchor, Item, List},
};
#[derive(Clone, Default, Debug)]
#[derive(Clone, Debug)]
pub struct State {
pub context: Context,
pub dom_ids: HashMap<String, Vec<String>>,
@ -15,7 +15,7 @@ pub struct State {
pub format_tokens: Vec<Token>,
}
#[derive(Clone, Default, Debug)]
#[derive(Clone, Debug)]
pub struct Switches {
pub bold: bool,
pub oblique: bool,
@ -23,13 +23,10 @@ pub struct Switches {
pub underline: bool,
}
#[derive(Clone, Default, Debug)]
#[derive(Clone, Debug)]
pub struct Buffers {
pub anchor: AnchorBuffer,
pub list: ListBuffer,
pub quote: QuoteBuffer,
pub table: TableBuffer,
pub preformat: PreFormatBuffer,
}
#[derive(Default, Clone, Debug)]
@ -46,25 +43,6 @@ pub struct AnchorBuffer {
pub destination: String,
}
#[derive(Default, Clone, Debug)]
pub struct QuoteBuffer {
pub candidate: Quote,
pub in_citation: bool,
}
#[derive(Default, Clone, Debug)]
pub struct TableBuffer {
pub candidate: Table,
pub cell: String,
pub in_cell: bool,
pub in_header: bool,
}
#[derive(Default, Clone, Debug)]
pub struct PreFormatBuffer {
pub candidate: PreFormat,
}
impl std::fmt::Display for AnchorBuffer {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let display_text = if self.text.is_empty() {
@ -89,6 +67,37 @@ impl std::fmt::Display for AnchorBuffer {
}
}
impl Default for State {
fn default() -> State {
State {
context: Context {
inline: Inline::None,
block: Block::None,
},
dom_ids: HashMap::default(),
switches: Switches {
bold: false,
crossout: false,
oblique: false,
underline: false,
},
buffers: Buffers {
anchor: AnchorBuffer {
candidate: Anchor::default(),
text: String::default(),
destination: String::default(),
},
list: ListBuffer {
candidate: List::default(),
item_candidate: Item::default(),
depth: 0,
},
},
format_tokens: vec![],
}
}
}
#[cfg(test)]
mod tests {
use super::*;
@ -107,24 +116,24 @@ mod tests {
#[test]
fn anchor_buffer_display_with_text_set() {
let mut buffer = AnchorBuffer::default();
buffer.text = String::from("mX8Z7sK");
buffer.text = String::from("mX8Z7yWmsK");
println!("{buffer:#?}");
println!("{buffer}");
assert_eq!(
format!("{buffer}"),
r#"AnchorBuffer [text: "mX8Z7sK"] >> Anchor <empty> -> <unknown>"#
r#"AnchorBuffer [text: "mX8Z7yWmsK"] >> Anchor <empty> -> <unknown>"#
);
}
#[test]
fn anchor_buffer_display_with_destination_set() {
let mut buffer = AnchorBuffer::default();
buffer.destination = String::from("VP2gAq");
buffer.destination = String::from("VP2aqGngAq");
println!("{buffer:#?}");
println!("{buffer}");
assert_eq!(
format!("{buffer}"),
r#"AnchorBuffer [, dest: "VP2gAq"] >> Anchor <empty> -> <unknown>"#
r#"AnchorBuffer [, dest: "VP2aqGngAq"] >> Anchor <empty> -> <unknown>"#
);
}
@ -137,10 +146,7 @@ mod tests {
println!("{buffer}");
assert_eq!(
format!("{buffer}"),
concat!(
r#"AnchorBuffer [text: "ECJrzgkBHg", dest: "9dy6gQ2g3E"] "#,
r#">> Anchor <empty> -> <unknown>"#,
)
r#"AnchorBuffer [text: "ECJrzgkBHg", dest: "9dy6gQ2g3E"] >> Anchor <empty> -> <unknown>"#
);
}
}

38
src/syntax/content/parser/token.rs
View file

@ -12,29 +12,15 @@ pub mod literal;
pub mod oblique;
pub mod paragraph;
pub mod preformat;
pub mod quote;
pub mod strike;
pub mod table;
pub mod underline;
pub mod verse;
pub use anchor::Anchor;
pub use bold::Bold;
pub use checkbox::CheckBox;
pub use code::Code;
pub use header::Header;
pub use item::Item;
pub use linebreak::LineBreak;
pub use list::List;
pub use literal::Literal;
pub use oblique::Oblique;
pub use paragraph::Paragraph;
pub use preformat::PreFormat;
pub use quote::Quote;
pub use strike::Strike;
pub use table::Table;
pub use underline::Underline;
pub use verse::Verse;
pub use {
anchor::Anchor, bold::Bold, checkbox::CheckBox, code::Code, header::Header,
item::Item, linebreak::LineBreak, list::List, literal::Literal,
oblique::Oblique, paragraph::Paragraph, preformat::PreFormat,
strike::Strike, underline::Underline,
};
#[derive(Debug, Eq, PartialEq, Clone)]
pub enum Token {
@ -51,10 +37,7 @@ pub enum Token {
Oblique(Oblique),
Paragraph(Paragraph),
PreFormat(PreFormat),
Quote(Quote),
Table(Table),
Underline(Underline),
Verse(Verse),
}
impl Token {
@ -73,10 +56,7 @@ impl Token {
Token::Oblique(d) => d.render(),
Token::Paragraph(d) => d.render(),
Token::PreFormat(d) => d.render(),
Token::Quote(d) => d.render(),
Token::Table(d) => d.render(),
Token::Underline(d) => d.render(),
Token::Verse(d) => d.render(),
}
}
@ -95,10 +75,7 @@ impl Token {
Token::Oblique(d) => d.flatten(),
Token::Paragraph(d) => d.flatten(),
Token::PreFormat(d) => d.flatten(),
Token::Quote(d) => d.flatten(),
Token::Table(d) => d.flatten(),
Token::Underline(d) => d.flatten(),
Token::Verse(d) => d.flatten(),
}
}
}
@ -119,10 +96,7 @@ impl std::fmt::Display for Token {
Token::Oblique(d) => format!("{d}"),
Token::Paragraph(d) => format!("{d}"),
Token::PreFormat(d) => format!("{d}"),
Token::Quote(d) => format!("{d}"),
Token::Table(d) => format!("{d}"),
Token::Underline(d) => format!("{d}"),
Token::Verse(d) => format!("{d}"),
};
write!(f, "Tk:{data}")

156
src/syntax/content/parser/token/anchor.rs
View file

@ -1,6 +1,6 @@
use crate::{
graph::Node,
syntax::content::{Parseable, parser::Lexeme},
graph::Node,
};
#[derive(Default, Debug, Clone, Eq, PartialEq)]
@ -11,54 +11,85 @@ pub struct Anchor {
node: Option<Node>,
leading: bool,
balanced: bool,
absolute: bool,
external: bool,
}
impl Anchor {
pub fn text(&self) -> String { self.text.clone() }
pub fn new(
text: &str,
destination: &str,
node: Option<Node>,
node_id: Option<String>,
leading: bool,
external: bool,
balanced: bool,
) -> Anchor {
let mut anchor = Anchor {
text: text.to_owned(),
destination: Some(String::from(destination)),
node,
node_id,
leading,
external,
balanced,
};
pub fn set_text(&mut self, text: &str) { self.text = String::from(text); }
anchor.route();
anchor
}
pub fn text_push(&mut self, text: &str) { self.text.push_str(text); }
pub fn text(&self) -> String {
self.text.clone()
}
pub fn destination(&self) -> Option<String> { self.destination.clone() }
pub fn set_text(&mut self, text: &str) {
self.text = String::from(text);
}
pub fn text_push(&mut self, text: &str) {
self.text.push_str(text);
}
pub fn destination(&self) -> Option<String> {
self.destination.clone()
}
pub fn set_destination(&mut self, destination: Option<&str>) {
self.destination = destination.map(str::to_string);
self.route();
}
pub const fn balanced(&self) -> bool { self.balanced }
pub fn balanced(&self) -> bool {
self.balanced
}
pub const fn set_balanced(&mut self, balanced: bool) {
pub fn set_balanced(&mut self, balanced: bool) {
self.balanced = balanced;
}
pub const fn absolute(&self) -> bool { self.absolute }
pub const fn set_absolute(&mut self, absolute: bool) {
self.absolute = absolute;
pub fn external(&self) -> bool {
self.external
}
pub const fn external(&self) -> bool { self.external }
pub const fn set_external(&mut self, external: bool) {
pub fn set_external(&mut self, external: bool) {
self.external = external;
self.absolute = true;
}
pub const fn set_leading(&mut self, leading: bool) {
pub fn set_leading(&mut self, leading: bool) {
self.leading = leading;
}
pub fn node(&self) -> Option<Node> { self.node.clone() }
pub fn node(&self) -> Option<Node> {
self.node.clone()
}
pub fn set_node(&mut self, node: &Node) {
self.node = Some(node.to_owned());
}
pub fn node_id(&self) -> Option<String> { self.node_id.clone() }
pub fn node_id(&self) -> Option<String> {
self.node_id.clone()
}
pub fn set_node_id(&mut self, id: &str) {
self.node_id = Some(id.to_owned());
@ -66,28 +97,21 @@ impl Anchor {
fn route(&mut self) {
self.destination = if let Some(destination) = self.destination.clone() {
if destination.contains(':') || destination.starts_with('/') {
if destination.contains(":") || destination.contains("/") {
Some(destination)
} else if destination.is_empty() && self.text.is_empty() {
None
} else if destination.is_empty() {
self.node_id = Some(Self::strip_fragment(&self.text));
self.node_id = Some(self.text.clone());
Some(format!("/node/{}", self.text))
} else {
self.node_id = self
.destination
.clone()
.map(|d| Anchor::strip_fragment(&d));
self.node_id = self.destination.clone();
Some(format!("/node/{destination}"))
}
} else {
None
}
}
fn strip_fragment(target: &str) -> String {
target.split('#').next().unwrap_or(target).to_string()
}
}
impl Parseable for Anchor {
@ -104,8 +128,7 @@ impl Parseable for Anchor {
fn render(&self) -> String {
let Some(destination) = &self.destination else {
panic!(
"Attempt to render anchor {self:#?} without knowing \
its destination."
"Attempt to render anchor {self:#?} without knowing its destination."
)
};
@ -115,40 +138,30 @@ impl Parseable for Anchor {
String::default()
};
let classes = if self.external {
String::from(r#"class="external""#)
} else if self.absolute {
String::from(r#"class="absolute""#)
} else if self.node.is_some() {
let classes = if self.node.is_some() {
String::from(r#"class="attached""#)
} else {
} else if !self.external {
String::from(r#"class="detached""#)
};
let text = if destination.contains('#')
&& !self.absolute
&& destination == &format!("/node/{}", self.text)
{
self.text
.split('#')
.next()
.unwrap_or(&self.text)
.to_string()
} else if self.external {
String::from(r#"class="external""#)
} else {
self.text.clone()
String::default()
};
format!(
r#"<a {classes} title="{summary}" href="{destination}">{text}</a>"#
r#"<a {classes} title="{summary}" href="{}">{}</a>"#,
destination, self.text,
)
}
fn flatten(&self) -> String { self.text.clone() }
fn flatten(&self) -> String {
self.text.clone()
}
}
impl std::fmt::Display for Anchor {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
use crate::dev::log::wrap;
use crate::log::wrap;
let wrapped_text = wrap(&self.text);
let display_text = if wrapped_text.is_empty() {
@ -187,9 +200,10 @@ impl std::fmt::Display for Anchor {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn render_anchor() {
let mut anchor = Anchor::default();
@ -197,10 +211,7 @@ mod tests {
anchor.set_destination(Some("AnchorDest"));
assert_eq!(
anchor.render(),
concat!(
r#"<a class="detached" title="" "#,
r#"href="/node/AnchorDest">AnchorText</a>"#,
)
r#"<a class="detached" title="" href="/node/AnchorDest">AnchorText</a>"#
);
}
@ -208,7 +219,9 @@ mod tests {
#[should_panic(
expected = "Attempt to lex an anchor directly from a lexeme"
)]
fn lex() { Anchor::lex(&Lexeme::default()); }
fn lex() {
Anchor::lex(&Lexeme::default());
}
#[test]
#[should_panic(expected = "without knowing its destination")]
@ -243,7 +256,7 @@ mod tests {
anchor.external = true;
assert_eq!(
format!("{}", Token::Anchor(Box::new(anchor))),
format!("{}", Token::Anchor(Box::new(anchor.clone()))),
"Tk:Anchor 'wPVo1 0OmYm' -> \"M1UEp 1gbfr\" \
+Leading +Balanced +External",
);
@ -274,29 +287,4 @@ mod tests {
anchor.route(); // set_destination also called this
assert!(anchor.destination().is_none());
}
#[test]
fn set_node_id() {
let payload = "kxBDJ0EoDVaygxpZ8NgNdQrUIBsGimTs";
let mut anchor = Anchor::default();
anchor.set_node_id(payload);
assert_eq!(anchor.node_id.unwrap(), payload);
}
#[test]
fn display_no_destination() {
let anchor = Anchor::default();
assert_eq!(format!("{anchor}"), "Anchor <empty> -> <unknown>");
}
#[test]
fn flatten() {
let payload = "tpBTViYnldoTqDsB";
let mut anchor = Anchor::default();
anchor.text = String::from(payload);
assert_eq!(anchor.flatten(), payload);
let token = Token::Anchor(Box::new(anchor));
assert_eq!(token.flatten(), payload);
}
}

37
src/syntax/content/parser/token/bold.rs
View file

@ -1,4 +1,6 @@
use crate::syntax::content::{Lexeme, Parseable};
use crate::{
syntax::content::{Parseable, Lexeme},
};
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Bold {
@ -6,11 +8,15 @@ pub struct Bold {
}
impl Bold {
pub const fn new(open: bool) -> Bold { Bold { open } }
pub fn new(open: bool) -> Bold {
Bold { open }
}
}
impl Parseable for Bold {
fn probe(lexeme: &Lexeme) -> bool { lexeme.text() == "*" }
fn probe(lexeme: &Lexeme) -> bool {
lexeme.text() == "*"
}
fn lex(_lexeme: &Lexeme) -> Bold {
panic!("Attempt to lex a bold tag directly from a lexeme")
@ -24,7 +30,9 @@ impl Parseable for Bold {
}
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
impl std::fmt::Display for Bold {
@ -36,9 +44,10 @@ impl std::fmt::Display for Bold {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn render() {
let code_open = Bold::new(true);
@ -52,7 +61,9 @@ mod tests {
#[should_panic(
expected = "Attempt to lex a bold tag directly from a lexeme"
)]
fn lex() { Bold::lex(&Lexeme::default()); }
fn lex() {
Bold::lex(&Lexeme::default());
}
#[test]
fn token_display() {
@ -60,15 +71,9 @@ mod tests {
assert_eq!(format!("{}", Token::Bold(bold.clone())), "Tk:Bold [open]");
bold.open = false;
assert_eq!(format!("{}", Token::Bold(bold)), "Tk:Bold [closed]");
}
#[test]
fn flatten() {
let bold = Bold::new(false);
assert_eq!(bold.flatten(), "");
let token = Token::Bold(bold);
assert_eq!(token.flatten(), "");
assert_eq!(
format!("{}", Token::Bold(bold.clone())),
"Tk:Bold [closed]"
);
}
}

26
src/syntax/content/parser/token/checkbox.rs
View file

@ -1,4 +1,6 @@
use crate::syntax::content::{Lexeme, Parseable};
use crate::{
syntax::content::{Parseable, Lexeme},
};
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct CheckBox {
@ -6,7 +8,9 @@ pub struct CheckBox {
}
impl CheckBox {
pub const fn new(checked: bool) -> CheckBox { CheckBox { checked } }
pub fn new(checked: bool) -> CheckBox {
CheckBox { checked }
}
}
impl Parseable for CheckBox {
@ -30,7 +34,9 @@ impl Parseable for CheckBox {
format!(r#"<input type="checkbox"{toggle}/>"#)
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
impl std::fmt::Display for CheckBox {
@ -42,9 +48,10 @@ impl std::fmt::Display for CheckBox {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn render() {
let code_open = CheckBox::new(true);
@ -64,17 +71,8 @@ mod tests {
checkbox.checked = false;
assert_eq!(
format!("{}", Token::CheckBox(checkbox)),
format!("{}", Token::CheckBox(checkbox.clone())),
"Tk:CheckBox [empty]"
);
}
#[test]
fn flatten() {
let checkbox = CheckBox::new(false);
assert_eq!(checkbox.flatten(), "");
let token = Token::CheckBox(checkbox);
assert_eq!(token.flatten(), "");
}
}

37
src/syntax/content/parser/token/code.rs
View file

@ -1,4 +1,6 @@
use crate::syntax::content::{Lexeme, Parseable};
use crate::{
syntax::content::{Parseable, Lexeme},
};
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Code {
@ -6,11 +8,15 @@ pub struct Code {
}
impl Code {
pub const fn new(open: bool) -> Code { Code { open } }
pub fn new(open: bool) -> Code {
Code { open }
}
}
impl Parseable for Code {
fn probe(lexeme: &Lexeme) -> bool { lexeme.text() == "`" }
fn probe(lexeme: &Lexeme) -> bool {
lexeme.text() == "`"
}
fn lex(_lexeme: &Lexeme) -> Code {
panic!("Attempt to lex a code tag directly from a lexeme")
@ -24,7 +30,9 @@ impl Parseable for Code {
}
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
impl std::fmt::Display for Code {
@ -36,9 +44,10 @@ impl std::fmt::Display for Code {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn render() {
let code_open = Code::new(true);
@ -52,7 +61,9 @@ mod tests {
#[should_panic(
expected = "Attempt to lex a code tag directly from a lexeme"
)]
fn lex() { Code::lex(&Lexeme::default()); }
fn lex() {
Code::lex(&Lexeme::default());
}
#[test]
fn token_display() {
@ -60,15 +71,9 @@ mod tests {
assert_eq!(format!("{}", Token::Code(code.clone())), "Tk:Code [open]");
code.open = false;
assert_eq!(format!("{}", Token::Code(code)), "Tk:Code [closed]");
}
#[test]
fn flatten() {
let code = Code::new(true);
assert_eq!(code.flatten(), "");
let token = Token::Code(code);
assert_eq!(token.flatten(), "");
assert_eq!(
format!("{}", Token::Code(code.clone())),
"Tk:Code [closed]"
);
}
}

55
src/syntax/content/parser/token/header.rs
View file

@ -1,14 +1,15 @@
use std::{
collections::{HashMap, hash_map::Entry},
fmt::Display,
};
use crate::{
graph::Config,
prelude::*,
syntax::content::{Lexeme, Parseable},
graph::Config,
syntax::content::{Parseable, Lexeme},
};
use std::fmt::Display;
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Header {
open: Option<bool>,
@ -32,7 +33,7 @@ impl Header {
) -> String {
let base_id = if !config.ascii_dom_ids || next_lexeme.next().is_ascii()
{
next_lexeme.next()
next_lexeme.next().clone()
} else {
String::from("h")
};
@ -60,7 +61,7 @@ impl Header {
}
}
pub const fn level(&self) -> u8 {
pub fn level(&self) -> u8 {
match self.level {
Level::One => 1,
Level::Two => 2,
@ -112,7 +113,9 @@ impl Parseable for Header {
}
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
impl std::fmt::Display for Header {
@ -147,7 +150,7 @@ pub enum Level {
}
impl Level {
const fn from_u8(u: u8) -> Level {
fn from_u8(u: u8) -> Level {
if u <= 1 {
Level::One
} else if u == 2 {
@ -192,9 +195,10 @@ impl Display for Level {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn make_id() {
let mut map: HashMap<String, Vec<String>> = HashMap::default();
@ -296,39 +300,4 @@ mod tests {
"Tk:Header [closed L2]"
);
}
#[test]
fn display_unknown_open_state() {
let header = Header {
open: None,
dom_id: None,
level: Level::One,
};
assert_eq!(format!("{header}"), "Header [unknown L1]");
}
#[test]
fn display_dom_id() {
let payload = "WIV0h1wCeY7Pp3FkjgIftJHX1I6YvnSc";
let header = Header {
open: None,
dom_id: Some(payload.to_string()),
level: Level::One,
};
assert_eq!(
format!("{header}"),
format!("Header [unknown L1 DOM ID {payload}]")
);
}
#[test]
fn flatten() {
let header = Header::new(Level::Two, true, Some("MNxqaFfIbCzw"));
assert_eq!(header.flatten(), "");
let token = Token::Header(header);
assert_eq!(token.flatten(), "");
}
}

34
src/syntax/content/parser/token/item.rs
View file

@ -1,4 +1,4 @@
use crate::syntax::content::{Lexeme, Parseable};
use crate::syntax::content::{Parseable, Lexeme};
#[derive(Default, Debug, Clone, Eq, PartialEq)]
pub struct Item {
@ -7,7 +7,9 @@ pub struct Item {
}
impl Parseable for Item {
fn probe(_: &Lexeme) -> bool { false }
fn probe(_: &Lexeme) -> bool {
false
}
fn lex(_: &Lexeme) -> Item {
panic!("Attempt to lex an item directly from a lexeme")
@ -17,7 +19,9 @@ impl Parseable for Item {
panic!("Items should only be rendered by a list's render method")
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
impl Item {
@ -46,26 +50,17 @@ impl std::fmt::Display for Item {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
#[test]
#[should_panic(
expected = "Items should only be rendered by a list's render method"
)]
fn token_render() {
let item = Item::new("aCNuZwwzrt", None);
item.render();
}
use super::*;
#[test]
#[should_panic(
expected = "Items should only be rendered by a list's render method"
)]
fn render() {
let item = Item::new("vuv3ipykTzuf", None);
let token = Token::Item(item);
token.render();
let item = Item::new("aCNuZwwzrt", None);
item.render();
}
#[test]
@ -90,15 +85,8 @@ mod tests {
);
item.depth = None;
assert_eq!(
format!("{}", Token::Item(item)),
format!("{}", Token::Item(item.clone())),
"Tk:Item [<unknown>] dRMy4"
);
}
#[test]
fn flatten() {
let item = Item::new("", None);
assert_eq!(item.flatten(), "");
assert_eq!(Token::Item(item).flatten(), "");
}
}

32
src/syntax/content/parser/token/linebreak.rs
View file

@ -1,18 +1,26 @@
use crate::syntax::content::{Parseable, parser::Lexeme};
use crate::{
syntax::content::{Parseable, parser::Lexeme},
};
#[derive(Default, Debug, Clone, Eq, PartialEq)]
pub struct LineBreak;
pub struct LineBreak {}
impl Parseable for LineBreak {
fn probe(lexeme: &Lexeme) -> bool {
lexeme.match_char('<') && lexeme.match_next_char('\n')
lexeme.text() == "\n" && !lexeme.last()
}
fn lex(_lexeme: &Lexeme) -> LineBreak { LineBreak {} }
fn lex(_lexeme: &Lexeme) -> LineBreak {
LineBreak {}
}
fn render(&self) -> String { String::from("<br>") }
fn render(&self) -> String {
"\n".to_owned()
}
fn flatten(&self) -> String { String::from('\n') }
fn flatten(&self) -> String {
String::from('\n')
}
}
impl std::fmt::Display for LineBreak {
@ -23,17 +31,13 @@ impl std::fmt::Display for LineBreak {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn token_display() {
assert_eq!(format!("{}", Token::LineBreak(LineBreak)), "Tk:LineBreak");
}
#[test]
fn flatten() {
assert_eq!(LineBreak.flatten(), "\n");
assert_eq!(Token::LineBreak(LineBreak).flatten(), "\n");
let linebreak = LineBreak::default();
assert_eq!(format!("{}", Token::LineBreak(linebreak)), "Tk:LineBreak");
}
}

68
src/syntax/content/parser/token/list.rs
View file

@ -1,5 +1,4 @@
use crate::{
prelude::*,
syntax::content::{
Parseable,
parser::{Lexeme, token::Item},
@ -21,14 +20,6 @@ impl Parseable for List {
panic!("Attempt to lex a List directly from a lexeme")
}
/// Renders the list to the equivalent HTML representation.
///
/// Performs checked arithmetic to the following effects:
/// - Strict division is performed but related panics are unreachable given
/// the guarantees described in `List::scale_indent`
/// - Saturates subtractions from indent levels at zero. This is not
/// unreachable, but a difference of zero is a no-op considering it would
/// cause an iteration of zero times (over an empty range).
fn render(&self) -> String {
let tag = if self.ordered { "ol" } else { "ul" };
let mut output = String::new();
@ -43,19 +34,19 @@ impl Parseable for List {
.unwrap_or(0)
.strict_div(scale);
write_log!(output, "<li>{}", item.text);
output.push_str(&format!("<li>{}", item.text));
if next_level > level {
// open nested lists
for _ in 0..(next_level.saturating_sub(level)) {
write_log!(output, "<{tag}>\n");
output.push_str(&format!("<{tag}>\n"));
}
} else {
// close current item
output.push_str("</li>");
// close nested lists
for _ in 0..(level.saturating_sub(next_level)) {
write_log!(output, "</{tag}></li>");
output.push_str(&format!("</{tag}></li>"));
}
output.push('\n');
}
@ -70,25 +61,13 @@ impl Parseable for List {
}
impl List {
pub const fn new(ordered: bool) -> List {
pub fn new(ordered: bool) -> List {
List {
ordered,
items: vec![],
}
}
/// Calculates the scale to normalize indents.
///
/// For example, if two contiguous items have differing indents of 2 and 4,
/// the indent scale is 2 and they can be normalized as having indents of
/// 1 and 2 respectively.
///
/// Performs checked arithmetic to the following effects:
/// - The subtraction of outer from inner saturates at 0 due to u8 being
/// unsigned, but such a case is unreachable given the outer condition
/// that guards this subtraction
/// - Will not return zero even if it is the calculated width, instead
/// logging the event and returning 1 instead
fn scale_indent(&self) -> u8 {
let width = self
.items
@ -100,13 +79,9 @@ impl List {
})
.unwrap_or(1);
if width == 0 {
log!("Scale indent of 0 can't be a divisor: returning 1 instead");
1
} else {
assert!(width != 0, "Width of zero can't be a divisor");
width
}
}
}
impl std::fmt::Display for List {
@ -122,9 +97,10 @@ impl std::fmt::Display for List {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn render_flat_list() {
let mut list = List::new(false);
@ -202,7 +178,7 @@ mod tests {
fn token_display() {
let list = List::new(false);
assert_eq!(
format!("{}", Token::List(list)),
format!("{}", Token::List(list.clone())),
"Tk:List [0 unordered items]"
);
}
@ -213,32 +189,4 @@ mod tests {
let lexeme = Lexeme::new("SL6PX", "6xsNB", "oeAHa");
List::lex(&lexeme);
}
#[test]
fn ordered_list() {
let mut list = List::new(true);
list.items = vec![
Item::new("a", Some(0)),
Item::new("b", Some(0)),
Item::new("c", Some(0)),
];
assert_eq!(
list.render(),
"\n<ol>\n\
<li>a</li>\n\
<li>b</li>\n\
<li>c</li>\n\
</ol>\n\n"
);
}
#[test]
fn flatten() {
let list = List::new(true);
assert_eq!(list.flatten(), "[List: 0 items]");
let token = Token::List(List::new(true));
assert_eq!(token.flatten(), "[List: 0 items]");
}
}

26
src/syntax/content/parser/token/literal.rs
View file

@ -16,22 +16,27 @@ impl Parseable for Literal {
}
}
fn render(&self) -> String { self.text.clone() }
fn render(&self) -> String {
self.text.clone()
}
fn flatten(&self) -> String { self.text.clone() }
fn flatten(&self) -> String {
self.text.clone()
}
}
impl std::fmt::Display for Literal {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "Literal {}", crate::dev::log::wrap(&self.text))
write!(f, "Literal {}", crate::log::wrap(&self.text))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn token_display() {
let mut literal = Literal {
@ -43,14 +48,9 @@ mod tests {
);
literal.text = String::from("TjY02");
assert_eq!(format!("{}", Token::Literal(literal)), "Tk:Literal TjY02");
}
#[test]
fn flatten() {
let payload = "vJtsvWD7ErYB";
let literal = Literal::lex(&Lexeme::new(payload, "", ""));
assert_eq!(literal.flatten(), payload);
assert_eq!(Token::Literal(literal).flatten(), payload);
assert_eq!(
format!("{}", Token::Literal(literal.clone())),
"Tk:Literal TjY02"
);
}
}

34
src/syntax/content/parser/token/oblique.rs
View file

@ -1,4 +1,6 @@
use crate::syntax::content::{Lexeme, Parseable};
use crate::{
syntax::content::{Parseable, Lexeme},
};
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Oblique {
@ -6,11 +8,15 @@ pub struct Oblique {
}
impl Oblique {
pub const fn new(open: bool) -> Oblique { Oblique { open } }
pub fn new(open: bool) -> Oblique {
Oblique { open }
}
}
impl Parseable for Oblique {
fn probe(lexeme: &Lexeme) -> bool { lexeme.text() == "_" }
fn probe(lexeme: &Lexeme) -> bool {
lexeme.text() == "_"
}
fn lex(_lexeme: &Lexeme) -> Oblique {
panic!("Attempt to lex an oblique tag directly from a lexeme")
@ -24,7 +30,9 @@ impl Parseable for Oblique {
}
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
impl std::fmt::Display for Oblique {
@ -36,9 +44,10 @@ impl std::fmt::Display for Oblique {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn render() {
let code_open = Oblique::new(true);
@ -52,7 +61,9 @@ mod tests {
#[should_panic(
expected = "Attempt to lex an oblique tag directly from a lexeme"
)]
fn lex() { Oblique::lex(&Lexeme::default()); }
fn lex() {
Oblique::lex(&Lexeme::default());
}
#[test]
fn token_display() {
@ -64,17 +75,8 @@ mod tests {
oblique.open = false;
assert_eq!(
format!("{}", Token::Oblique(oblique)),
format!("{}", Token::Oblique(oblique.clone())),
"Tk:Oblique [closed]"
);
}
#[test]
fn flatten() {
let oblique = Oblique::new(false);
assert_eq!(oblique.flatten(), "");
let token = Token::Oblique(oblique);
assert_eq!(token.flatten(), "");
}
}

33
src/syntax/content/parser/token/paragraph.rs
View file

@ -6,7 +6,9 @@ pub struct Paragraph {
}
impl Paragraph {
pub const fn new(open: bool) -> Paragraph { Paragraph { open: Some(open) } }
pub fn new(open: bool) -> Paragraph {
Paragraph { open: Some(open) }
}
pub fn probe_end(lexeme: &Lexeme) -> bool {
lexeme.match_char('\n') && lexeme.match_next_char('\n')
@ -19,7 +21,9 @@ impl Parseable for Paragraph {
!lexeme.is_whitespace()
}
fn lex(_lexeme: &Lexeme) -> Paragraph { Paragraph { open: None } }
fn lex(_lexeme: &Lexeme) -> Paragraph {
Paragraph { open: None }
}
fn render(&self) -> String {
if let Some(open) = self.open {
@ -35,7 +39,9 @@ impl Parseable for Paragraph {
}
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
impl std::fmt::Display for Paragraph {
@ -56,9 +62,10 @@ impl std::fmt::Display for Paragraph {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn lex() {
let p = Paragraph::lex(&Lexeme::default());
@ -66,8 +73,9 @@ mod tests {
}
#[test]
#[should_panic(expected = "Attempt to render a paragraph tag while \
open state is unknown")]
#[should_panic(
expected = "Attempt to render a paragraph tag while open state is unknown"
)]
fn render_state_unknown() {
let p = Paragraph::lex(&Lexeme::default());
drop(p.render());
@ -89,19 +97,8 @@ mod tests {
paragraph.open = None;
assert_eq!(
format!("{}", Token::Paragraph(paragraph)),
format!("{}", Token::Paragraph(paragraph.clone())),
"Tk:Paragraph [unknown]"
);
}
#[test]
fn flatten() {
let open = Paragraph::new(true);
let closed = Paragraph::new(false);
assert_eq!(open.flatten(), "");
assert_eq!(closed.flatten(), "");
assert_eq!(Token::Paragraph(open).flatten(), "");
assert_eq!(Token::Paragraph(closed).flatten(), "");
}
}

93
src/syntax/content/parser/token/preformat.rs
View file

@ -1,87 +1,102 @@
use crate::syntax::content::{Lexeme, Parseable};
use crate::{
syntax::content::{Parseable, Lexeme},
};
#[derive(Debug, Default, Clone, Eq, PartialEq)]
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct PreFormat {
pub text: String,
open: Option<bool>,
}
impl PreFormat {
pub fn new(text: &str) -> PreFormat {
PreFormat {
text: String::from(text),
}
pub fn new(open: bool) -> PreFormat {
PreFormat { open: Some(open) }
}
}
impl std::fmt::Display for PreFormat {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let character_count = self.text.chars().count();
let is_whitespace = self.text.trim_ascii().is_empty();
let summary = if is_whitespace {
"empty"
let display_open_state = if let Some(open_state) = self.open {
if open_state { "open" } else { "closed" }
} else {
&format!("{character_count} chars")
"unknown"
};
write!(f, "PreFormat [{summary}]")
write!(f, "PreFormat [{display_open_state}]")
}
}
impl Parseable for PreFormat {
fn probe(lexeme: &Lexeme) -> bool {
lexeme.match_char('`') && (lexeme.next() == "\n" || lexeme.last())
lexeme.match_first_char('`') && (lexeme.next() == "\n" || lexeme.last())
}
fn lex(_lexeme: &Lexeme) -> PreFormat {
panic!("Attempt to lex a preformat directly from a lexeme")
PreFormat { open: None }
}
fn render(&self) -> String { format!("<pre>{}</pre>", self.text) }
fn render(&self) -> String {
if let Some(o) = self.open {
if o {
"<pre>".to_owned()
} else {
"</pre>".to_owned()
}
} else {
panic!(
"Attempt to render a preformat tag while open state is unknown"
)
}
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn lex() {
let from_empty_lexeme = PreFormat::lex(&Lexeme::default());
assert!(from_empty_lexeme.open.is_none());
let from_non_empty_lexeme = PreFormat::lex(&Lexeme::default());
assert!(from_non_empty_lexeme.open.is_none());
}
#[test]
#[should_panic(
expected = "Attempt to lex a preformat directly from a lexeme"
expected = "Attempt to render a preformat tag while open state is unknown"
)]
fn lex() {
let lexeme = Lexeme::new("a", "b", "c");
PreFormat::lex(&lexeme);
fn render() {
let from_empty_lexeme = PreFormat::lex(&Lexeme::default());
from_empty_lexeme.render();
let from_non_empty_lexeme = PreFormat::lex(&Lexeme::default());
from_non_empty_lexeme.render();
}
#[test]
fn token_display() {
let mut preformat = PreFormat::new("");
let mut preformat = PreFormat::new(true);
assert_eq!(
format!("{}", Token::PreFormat(preformat.clone())),
"Tk:PreFormat [empty]"
"Tk:PreFormat [open]"
);
preformat.text = "\n ".to_string();
preformat.open = Some(false);
assert_eq!(
format!("{}", Token::PreFormat(preformat.clone())),
"Tk:PreFormat [empty]"
"Tk:PreFormat [closed]"
);
preformat.text = "text".to_string();
preformat.open = None;
assert_eq!(
format!("{}", Token::PreFormat(preformat)),
"Tk:PreFormat [4 chars]"
format!("{}", Token::PreFormat(preformat.clone())),
"Tk:PreFormat [unknown]"
);
}
#[test]
fn flatten() {
let preformat = PreFormat::new("");
assert_eq!(preformat.flatten(), "");
let token = Token::PreFormat(preformat);
assert_eq!(token.flatten(), "");
}
}

166
src/syntax/content/parser/token/quote.rs
View file

@ -1,166 +0,0 @@
use crate::syntax::content::{Parseable, parser::Lexeme};
#[derive(Debug, Default, Clone, Eq, PartialEq)]
pub struct Quote {
pub text: String,
pub citation: Option<String>,
pub url: Option<String>,
}
impl Quote {
pub fn probe_end(lexeme: &Lexeme) -> bool {
lexeme.match_char_sequence('\n', '\n')
}
pub fn extend_citation(&mut self, s: &str) {
if let Some(current) = &self.citation {
self.citation = Some(format!("{current}{s}"));
} else {
self.citation = Some(String::from(s));
}
}
}
impl Parseable for Quote {
fn probe(lexeme: &Lexeme) -> bool {
lexeme.match_char('>') && lexeme.match_next_char(' ')
}
fn lex(_lexeme: &Lexeme) -> Quote {
panic!("Attempt to lex a quote directly from a lexeme")
}
fn render(&self) -> String {
let opening = if let Some(url) = &self.url {
format!(r#"<blockquote cite="{url}">"#)
} else {
String::from("<blockquote>")
};
let content = if let Some(citation) = &self.citation {
format!(
r#"{}<br/><cite class="quote-citation">{citation}</cite>"#,
self.text
)
} else {
String::from(&self.text)
};
format!("\n{opening}\n{content}\n</blockquote>\n")
}
fn flatten(&self) -> String {
if let Some(citation) = &self.citation {
format!(r#""{}" -- {}"#, self.text, citation)
} else {
format!(r#""{}""#, self.text)
}
}
}
impl std::fmt::Display for Quote {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let mut meta = String::default();
if self.url.is_some() {
meta.push_str("+url ");
}
if self.citation.is_some() {
meta.push_str("+citation ");
}
write!(f, "Quote [{}]", meta.trim())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
#[test]
fn display() {
let mut quote_slim = Quote::default();
quote_slim.text = "iXh0141J7B8P46Gv".to_string();
println!("{quote_slim}");
assert!(format!("{quote_slim}").contains("Quote"));
assert!(!format!("{quote_slim}").contains("+url"));
assert!(!format!("{quote_slim}").contains("+citation"));
assert_eq!(format!("{}", Token::Quote(quote_slim)), "Tk:Quote []");
let mut quote_cited = Quote::default();
quote_cited.text = "iXh0141J7B8P46Gv".to_string();
quote_cited.citation = Some("k8Fy7htmvi2NG7yh".to_string());
println!("{quote_cited}");
assert!(format!("{quote_cited}").contains("Quote"));
assert!(!format!("{quote_cited}").contains("+url"));
assert!(format!("{quote_cited}").contains("+citation"));
assert_eq!(
format!("{}", Token::Quote(quote_cited)),
"Tk:Quote [+citation]",
);
let mut quote_with_url = Quote::default();
quote_with_url.text = "iXh0141J7B8P46Gv".to_string();
quote_with_url.url = Some("CttVJU2IHDsjSjao".to_string());
println!("{quote_with_url}");
assert!(format!("{quote_with_url}").contains("Quote"));
assert!(format!("{quote_with_url}").contains("+url"));
assert!(!format!("{quote_with_url}").contains("+citation"));
assert_eq!(
format!("{}", Token::Quote(quote_with_url)),
"Tk:Quote [+url]",
);
let mut quote_full = Quote::default();
quote_full.text = "iXh0141J7B8P46Gv".to_string();
quote_full.citation = Some("k8Fy7htmvi2NG7yh".to_string());
quote_full.url = Some("CttVJU2IHDsjSjao".to_string());
println!("{quote_full}");
assert!(format!("{quote_full}").contains("Quote"));
assert!(format!("{quote_full}").contains("+url"));
assert!(format!("{quote_full}").contains("+citation"));
assert_eq!(
format!("{}", Token::Quote(quote_full)),
"Tk:Quote [+url +citation]",
);
}
#[test]
fn flatten() {
assert_eq!(Quote::default().flatten(), r#""""#);
let mut without_citation = Quote::default();
let text = "AphyFDQHVbkOeaNw";
without_citation.text = text.to_string();
assert_eq!(without_citation.flatten(), format!(r#""{text}""#));
let without_citation_token = Token::Quote(without_citation);
assert_eq!(without_citation_token.flatten(), format!(r#""{text}""#));
let mut with_citation = Quote::default();
let citation = "B35rcofYM0J7";
with_citation.text = text.to_string();
with_citation.citation = Some(citation.to_string());
assert_eq!(
with_citation.flatten(),
format!(r#""{text}" -- {citation}"#)
);
let with_citation_token = Token::Quote(with_citation);
assert_eq!(
with_citation_token.flatten(),
format!(r#""{text}" -- {citation}"#)
);
}
#[test]
#[should_panic(expected = "Attempt to lex a quote directly from a lexeme")]
fn lex() {
let lexeme = Lexeme::new("z2UI", "FiCd", "rtq4");
Quote::lex(&lexeme);
}
}

33
src/syntax/content/parser/token/strike.rs
View file

@ -1,4 +1,6 @@
use crate::syntax::content::{Lexeme, Parseable};
use crate::{
syntax::content::{Parseable, Lexeme},
};
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Strike {
@ -6,7 +8,9 @@ pub struct Strike {
}
impl Strike {
pub const fn new(open: bool) -> Strike { Strike { open } }
pub fn new(open: bool) -> Strike {
Strike { open }
}
}
impl Parseable for Strike {
@ -23,7 +27,9 @@ impl Parseable for Strike {
String::from(tag)
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
impl std::fmt::Display for Strike {
@ -35,9 +41,10 @@ impl std::fmt::Display for Strike {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn render() {
let code_open = Strike::new(true);
@ -51,7 +58,9 @@ mod tests {
#[should_panic(
expected = "Attempt to lex a strike tag directly from a lexeme"
)]
fn lex() { Strike::lex(&Lexeme::default()); }
fn lex() {
Strike::lex(&Lexeme::default());
}
#[test]
fn token_display() {
@ -62,15 +71,9 @@ mod tests {
);
strike.open = false;
assert_eq!(format!("{}", Token::Strike(strike)), "Tk:Strike [closed]");
}
#[test]
fn flatten() {
let strike = Strike::new(false);
assert_eq!(strike.flatten(), "");
let token = Token::Strike(strike);
assert_eq!(token.flatten(), "");
assert_eq!(
format!("{}", Token::Strike(strike.clone())),
"Tk:Strike [closed]"
);
}
}

169
src/syntax/content/parser/token/table.rs
View file

@ -1,169 +0,0 @@
use crate::syntax::content::{Parseable, parser::Lexeme};
#[derive(Debug, Default, Clone, Eq, PartialEq)]
pub struct Table {
pub headers: Vec<String>,
pub contents: Vec<Vec<String>>,
}
impl Table {
pub fn probe_end(lexeme: &Lexeme) -> bool {
lexeme.match_char_triple('\n', '%', '\n') || lexeme.last()
}
pub fn add_header(&mut self, header: &str) {
self.headers.push(header.trim().to_string());
}
pub fn add_row(&mut self, row: Vec<String>) { self.contents.push(row); }
pub fn add_cell(&mut self, content: &str) {
if let Some(last) = self.contents.last_mut() {
last.push(content.trim().to_string());
} else {
self.contents.push(vec![content.trim().to_string()]);
}
}
/// Counts the number of cells in the last row.
pub fn last_row_count(&self) -> usize {
if let Some(last) = self.contents.last() {
last.len()
} else {
0
}
}
}
impl Parseable for Table {
fn probe(lexeme: &Lexeme) -> bool { lexeme.match_char_sequence('%', '\n') }
fn lex(_lexeme: &Lexeme) -> Table {
panic!("Attempt to lex a table directly from a lexeme")
}
fn render(&self) -> String {
let mut xml = String::from("\n<table>\n");
let tab = " ";
if !self.headers.is_empty() {
xml.push_str(format!("{tab}<tr>\n").as_str());
for header in &self.headers {
xml.push_str(format!("{tab}{tab}<th>{header}</th>\n").as_str());
}
xml.push_str(format!("{tab}</tr>\n").as_str());
}
for row in &self.contents {
if !row.is_empty() && row.iter().any(|cell| !cell.is_empty()) {
xml.push_str(format!("{tab}<tr>\n").as_str());
for cell in row {
xml.push_str(
format!("{tab}{tab}<td>{cell}</td>\n").as_str(),
);
}
xml.push_str(format!("{tab}</tr>\n").as_str());
}
}
xml.push_str("</table>\n");
xml
}
fn flatten(&self) -> String { String::from("[Table]") }
}
impl std::fmt::Display for Table {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let headers_width = self.headers.len();
let contents_height = self.contents.len();
let contents_width = self.last_row_count();
let mut extra = String::default();
if headers_width > 0 && contents_height > 0 {
extra = format!(
" [{contents_width}x{contents_height} +{headers_width} headers]"
);
} else if headers_width > 0 {
extra = format!(" [+{headers_width} headers]");
} else if contents_height > 0 {
extra = format!(" [{contents_width}x{contents_height}]");
}
write!(f, "Table{extra}")
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
#[test]
#[should_panic(expected = "Attempt to lex a table directly from a lexeme")]
fn lex() {
let lexeme = Lexeme::new("tp0h", "rrFt", "Qouf");
Table::lex(&lexeme);
}
#[test]
fn flatten() {
assert_eq!(Table::default().flatten(), "[Table]");
assert_eq!(Token::Table(Table::default()).flatten(), "[Table]");
}
#[test]
fn display() {
use std::string::ToString;
let mut table = Table::default();
table.add_header("A");
table.add_header("B");
table.add_header("C");
let table_token = Token::Table(table.clone());
assert_eq!(format!("{table}"), "Table [+3 headers]");
assert_eq!(format!("{table_token}"), "Tk:Table [+3 headers]");
table.add_row(
["1", "2", "3"]
.iter()
.map(ToString::to_string)
.collect::<Vec<String>>(),
);
table.add_row(
["4", "5", "6"]
.iter()
.map(ToString::to_string)
.collect::<Vec<String>>(),
);
table.add_row(
["7", "8", "9"]
.iter()
.map(ToString::to_string)
.collect::<Vec<String>>(),
);
let table_token2 = Token::Table(table.clone());
assert_eq!(format!("{table}"), "Table [3x3 +3 headers]");
assert_eq!(format!("{table_token2}"), "Tk:Table [3x3 +3 headers]");
let mut table2 = Table::default();
table2.add_row(
["1", "2", "3"]
.iter()
.map(ToString::to_string)
.collect::<Vec<String>>(),
);
table2.add_row(
["2", "4", "6"]
.iter()
.map(ToString::to_string)
.collect::<Vec<String>>(),
);
let table2_token = Token::Table(table2.clone());
assert_eq!(format!("{table2}"), "Table [3x2]");
assert_eq!(format!("{table2_token}"), "Tk:Table [3x2]");
}
}

30
src/syntax/content/parser/token/underline.rs
View file

@ -1,4 +1,6 @@
use crate::syntax::content::{Lexeme, Parseable};
use crate::{
syntax::content::{Parseable, Lexeme},
};
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Underline {
@ -6,7 +8,9 @@ pub struct Underline {
}
impl Underline {
pub const fn new(open: bool) -> Underline { Underline { open } }
pub fn new(open: bool) -> Underline {
Underline { open }
}
}
impl Parseable for Underline {
@ -26,7 +30,9 @@ impl Parseable for Underline {
}
}
fn flatten(&self) -> String { String::default() }
fn flatten(&self) -> String {
String::default()
}
}
impl std::fmt::Display for Underline {
@ -38,9 +44,10 @@ impl std::fmt::Display for Underline {
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
use super::*;
#[test]
fn render() {
let code_open = Underline::new(true);
@ -54,7 +61,9 @@ mod tests {
#[should_panic(
expected = "Attempt to lex an underline tag directly from a lexeme"
)]
fn lex() { Underline::lex(&Lexeme::default()); }
fn lex() {
Underline::lex(&Lexeme::default());
}
#[test]
fn token_display() {
@ -66,17 +75,8 @@ mod tests {
underline.open = false;
assert_eq!(
format!("{}", Token::Underline(underline)),
format!("{}", Token::Underline(underline.clone())),
"Tk:Underline [closed]"
);
}
#[test]
fn flatten() {
let underline = Underline::new(false);
assert_eq!(underline.flatten(), "");
let token = Token::Underline(underline);
assert_eq!(token.flatten(), "");
}
}

101
src/syntax/content/parser/token/verse.rs
View file

@ -1,101 +0,0 @@
use crate::syntax::content::{Parseable, parser::Lexeme};
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Verse {
open: Option<bool>,
}
impl Verse {
pub const fn new(open: bool) -> Verse { Verse { open: Some(open) } }
pub fn probe_end(lexeme: &Lexeme) -> bool {
lexeme.match_char_triple('\n', '&', '\n')
}
}
impl Parseable for Verse {
fn probe(lexeme: &Lexeme) -> bool {
lexeme.match_char_triple('\n', '&', '\n')
}
fn lex(_lexeme: &Lexeme) -> Verse { Verse { open: None } }
fn render(&self) -> String {
if let Some(open) = self.open {
if open {
concat!("\n", r#"<p class="verse">"#).to_string()
} else {
"\n</p>\n".to_owned()
}
} else {
panic!("Attempt to render a verse tag while open state is unknown")
}
}
fn flatten(&self) -> String { String::default() }
}
impl std::fmt::Display for Verse {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let display_open_state = match self.open {
Some(open_state) => {
if open_state {
"open"
} else {
"closed"
}
},
None => "unknown",
};
write!(f, "Verse [{display_open_state}]")
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::syntax::content::parser::Token;
#[test]
fn lexed_verse_is_empty() {
let verse = Verse::lex(&Lexeme::default());
assert!(verse.open.is_none());
}
#[test]
fn flatten() {
let verse = Verse::new(true);
assert!(verse.flatten().is_empty());
let token = Token::Verse(verse);
assert_eq!(token.flatten(), "");
}
#[test]
#[should_panic(
expected = "Attempt to render a verse tag while open state is unknown"
)]
fn render_attempt_with_unknown_open_state() {
let verse = Verse::lex(&Lexeme::default());
verse.render();
}
#[test]
fn display() {
let open = Verse::new(true);
let open_token = Token::Verse(open.clone());
assert_eq!(format!("{open}"), "Verse [open]");
assert_eq!(format!("{open_token}"), "Tk:Verse [open]");
let closed = Verse::new(false);
let closed_token = Token::Verse(closed.clone());
assert_eq!(format!("{closed}"), "Verse [closed]");
assert_eq!(format!("{closed_token}"), "Tk:Verse [closed]");
let unknown = Verse::lex(&Lexeme::default());
let unknown_token = Token::Verse(unknown.clone());
assert_eq!(format!("{unknown}"), "Verse [unknown]");
assert_eq!(format!("{unknown_token}"), "Tk:Verse [unknown]");
}
}

80
static/graph-schema.json
View file

@ -1,80 +0,0 @@
{
"$id": "https://git.jutty.dev/jutty/en/raw/branch/main/static/graph-schema.json",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"title": "Graph",
"description": "An en graph file",
"type": "object",
"$defs": {
"node": {
"type": "object",
"title": "Node",
"description": "A node object.",
"example": "[nodes.Earth]\ntext = \"Earth is a planet of the solar system.\"",
"default": null,
"properties": {
"text": {
"type": "string",
"description": "The text content of this node."
},
"title": {
"type": "string",
"description": "The node display title, useful to make it distinct from the ID.",
"default": "The node's ID."
},
"listed": {
"type": "boolean",
"description": "Whether this node is shown in listing pages.",
"default": true
},
"redirect": {
"type": "string",
"description": "A node ID to where any requests for this node will be redirected.",
"default": null
}
},
"additionalProperties": false
}
},
"properties": {
"root_node": {
"type": "string",
"title": "Root node ID",
"description": "The ID of node highlighted in the homepage as the graph root.",
"example": "MyNode",
"default": null
},
"nodes": {
"title": "Nodes",
"description": "The graph's nodes.",
"default": null,
"type": "object",
"additionalProperties": {
"$ref": "#/$defs/node"
},
"propertyNames": {
"pattern": "^[^-][^!@#$%^&*;:/~| \\]\\[()\\\\]*$"
}
},
"meta": {
"type": "object",
"properties": {
"config": {
"type": "object",
"properties": {
"content_language": { "type": "string" },
"footer_credits": { "type": "boolean" },
"error_poem": { "type": "boolean" },
"node_selector": { "type": "boolean" },
"navbar_search": { "type": "boolean" },
"about": { "type": "boolean" },
"footer_text": { "type": "string" },
"acknowledgments": { "type": "string" }
},
"additionalProperties": false
}
},
"additionalProperties": false
}
},
"additionalProperties": false
}

947
static/graph.toml
View file

File diff suppressed because it is too large Load diff

2
static/public/assets/fonts/.gitignore vendored
View file

@ -1,2 +0,0 @@
**/*.compact.LICENSE
**/compact.LICENSE

21
static/public/assets/fonts/LICENSES.sha256sum
View file

@ -1,21 +0,0 @@
9cc97638cf0185884ac800144b6246c7772f94ff2cc70686afa9574aaea4fa2b ./_canon/CC_BY_ND_4_0_INTERNATIONAL.LICENSE
00b6b2ffad0a8a99a0497b6474d16296adb91a9d9d83dd745d3148176aa16b7e ./_canon/CC_BY_ND_4_0_INTERNATIONAL.body.LICENSE
5f1cc99e4d0fe6ed3495b8f7fb57bdd07623b99a9f0b2bde6076ef3719f162f9 ./_canon/CC_BY_ND_4_0_INTERNATIONAL.compact.LICENSE
1d361a8f8e8ce6e68457dcd93fb56e162e6baa3bbb7e7573a290d44399f6b57e ./_canon/SIL_OFL_1_1.LICENSE
6863ff4dc820f24756b6acfb38a2c6bc19d5b8d71b17030330a6f16eb4cee348 ./_canon/SIL_OFL_1_1.body.LICENSE
2533bdb563fb91d70cb719edca0a0cdc8f5cc347d567561b4a87e7509e02073d ./_canon/SIL_OFL_1_1.compact.LICENSE
3f70f82d58c8f58b91cf8d718621ac1537234eb6f37ee9a83469a321ef46e4db ./cormorant/LICENSE
2533bdb563fb91d70cb719edca0a0cdc8f5cc347d567561b4a87e7509e02073d ./cormorant/compact.LICENSE
c110f34253aced57d6d4f02edce58b171dca3340591a1119e02ea084a4b78f93 ./cormorant/header.LICENSE
7d5da66dc426b59bbba125049b7016f2011f93724ddf7b7f97ce1911f958b963 ./maven/LICENSE
2533bdb563fb91d70cb719edca0a0cdc8f5cc347d567561b4a87e7509e02073d ./maven/compact.LICENSE
c63dd928ccd5c2c80491b84d1874227536dfced1f1f82cbd900ddc86c59b738b ./maven/header.LICENSE
1d2892790cc9522de02d3f01ba48d12742862b1a69d04d69752938591efabecd ./mononoki/LICENSE
2533bdb563fb91d70cb719edca0a0cdc8f5cc347d567561b4a87e7509e02073d ./mononoki/compact.LICENSE
20601bbaafe0fe8d6a39527785fc501f242ebae18d1aaa4d5d15a8ac4ff4fff3 ./mononoki/header.LICENSE
3e57bc17e8ece63050a2ac5aa99a80f87183289b18303d46311199875b4808b7 ./rawengulk/LICENSE
2533bdb563fb91d70cb719edca0a0cdc8f5cc347d567561b4a87e7509e02073d ./rawengulk/compact.LICENSE
4d8b5ec962dfeb2813bdeb0762e3b714e68e19f9fbcdb3481d12f018b125308b ./rawengulk/header.LICENSE
18837f5b671bd48dc6b595a475d8c45ab3e6ae33adb65d9bbeac59c58f77bc24 ./reforma/LICENSE
2edceb2f872692052b281629777bc5af5386601dd4c437f297f84846f9fa75cf ./reforma/compact.LICENSE
a3d29ef378426d0b1d9f17364a3d7532ad623a51c8c19a3badc74c23e5e93ef6 ./reforma/header.LICENSE

9
static/public/assets/fonts/README.md
View file

@ -1,9 +0,0 @@
## Known issues
As documented by the source files and hashes in this directory, significant effort was made to preserve the original license files, determine that equally-licensed files have identical licenses and that the vendored license files match the upstream well-known official versions.
In particular, the vendored file for the Reforma font is in Markdown format and as such hard to match against the license file supplied by Creative Commons without substantial reductions in punctuation, spacing and external URLs.
However, because only this font uses such license, it is still a single copy that must end up embedded in the binary. As such, despite a missing matching hash, the vendored version is embedded as-is.
Due to this issue, it was decided that any future font that is a candidate for addition to the project MUST be licensed under some version of the SIL Open Font License.

393
static/public/assets/fonts/_canon/CC_BY_ND_4_0_INTERNATIONAL.LICENSE
View file

@ -1,393 +0,0 @@
Attribution-NoDerivatives 4.0 International
=======================================================================
Creative Commons Corporation ("Creative Commons") is not a law firm and
does not provide legal services or legal advice. Distribution of
Creative Commons public licenses does not create a lawyer-client or
other relationship. Creative Commons makes its licenses and related
information available on an "as-is" basis. Creative Commons gives no
warranties regarding its licenses, any material licensed under their
terms and conditions, or any related information. Creative Commons
disclaims all liability for damages resulting from their use to the
fullest extent possible.
Using Creative Commons Public Licenses
Creative Commons public licenses provide a standard set of terms and
conditions that creators and other rights holders may use to share
original works of authorship and other material subject to copyright
and certain other rights specified in the public license below. The
following considerations are for informational purposes only, are not
exhaustive, and do not form part of our licenses.
Considerations for licensors: Our public licenses are
intended for use by those authorized to give the public
permission to use material in ways otherwise restricted by
copyright and certain other rights. Our licenses are
irrevocable. Licensors should read and understand the terms
and conditions of the license they choose before applying it.
Licensors should also secure all rights necessary before
applying our licenses so that the public can reuse the
material as expected. Licensors should clearly mark any
material not subject to the license. This includes other CC-
licensed material, or material used under an exception or
limitation to copyright. More considerations for licensors:
wiki.creativecommons.org/Considerations_for_licensors
Considerations for the public: By using one of our public
licenses, a licensor grants the public permission to use the
licensed material under specified terms and conditions. If
the licensor's permission is not necessary for any reason--for
example, because of any applicable exception or limitation to
copyright--then that use is not regulated by the license. Our
licenses grant only permissions under copyright and certain
other rights that a licensor has authority to grant. Use of
the licensed material may still be restricted for other
reasons, including because others have copyright or other
rights in the material. A licensor may make special requests,
such as asking that all changes be marked or described.
Although not required by our licenses, you are encouraged to
respect those requests where reasonable. More considerations
for the public:
wiki.creativecommons.org/Considerations_for_licensees
=======================================================================
Creative Commons Attribution-NoDerivatives 4.0 International Public
License
By exercising the Licensed Rights (defined below), You accept and agree
to be bound by the terms and conditions of this Creative Commons
Attribution-NoDerivatives 4.0 International Public License ("Public
License"). To the extent this Public License may be interpreted as a
contract, You are granted the Licensed Rights in consideration of Your
acceptance of these terms and conditions, and the Licensor grants You
such rights in consideration of benefits the Licensor receives from
making the Licensed Material available under these terms and
conditions.
Section 1 -- Definitions.
a. Adapted Material means material subject to Copyright and Similar
Rights that is derived from or based upon the Licensed Material
and in which the Licensed Material is translated, altered,
arranged, transformed, or otherwise modified in a manner requiring
permission under the Copyright and Similar Rights held by the
Licensor. For purposes of this Public License, where the Licensed
Material is a musical work, performance, or sound recording,
Adapted Material is always produced where the Licensed Material is
synched in timed relation with a moving image.
b. Copyright and Similar Rights means copyright and/or similar rights
closely related to copyright including, without limitation,
performance, broadcast, sound recording, and Sui Generis Database
Rights, without regard to how the rights are labeled or
categorized. For purposes of this Public License, the rights
specified in Section 2(b)(1)-(2) are not Copyright and Similar
Rights.
c. Effective Technological Measures means those measures that, in the
absence of proper authority, may not be circumvented under laws
fulfilling obligations under Article 11 of the WIPO Copyright
Treaty adopted on December 20, 1996, and/or similar international
agreements.
d. Exceptions and Limitations means fair use, fair dealing, and/or
any other exception or limitation to Copyright and Similar Rights
that applies to Your use of the Licensed Material.
e. Licensed Material means the artistic or literary work, database,
or other material to which the Licensor applied this Public
License.
f. Licensed Rights means the rights granted to You subject to the
terms and conditions of this Public License, which are limited to
all Copyright and Similar Rights that apply to Your use of the
Licensed Material and that the Licensor has authority to license.
g. Licensor means the individual(s) or entity(ies) granting rights
under this Public License.
h. Share means to provide material to the public by any means or
process that requires permission under the Licensed Rights, such
as reproduction, public display, public performance, distribution,
dissemination, communication, or importation, and to make material
available to the public including in ways that members of the
public may access the material from a place and at a time
individually chosen by them.
i. Sui Generis Database Rights means rights other than copyright
resulting from Directive 96/9/EC of the European Parliament and of
the Council of 11 March 1996 on the legal protection of databases,
as amended and/or succeeded, as well as other essentially
equivalent rights anywhere in the world.
j. You means the individual or entity exercising the Licensed Rights
under this Public License. Your has a corresponding meaning.
Section 2 -- Scope.
a. License grant.
1. Subject to the terms and conditions of this Public License,
the Licensor hereby grants You a worldwide, royalty-free,
non-sublicensable, non-exclusive, irrevocable license to
exercise the Licensed Rights in the Licensed Material to:
a. reproduce and Share the Licensed Material, in whole or
in part; and
b. produce and reproduce, but not Share, Adapted Material.
2. Exceptions and Limitations. For the avoidance of doubt, where
Exceptions and Limitations apply to Your use, this Public
License does not apply, and You do not need to comply with
its terms and conditions.
3. Term. The term of this Public License is specified in Section
6(a).
4. Media and formats; technical modifications allowed. The
Licensor authorizes You to exercise the Licensed Rights in
all media and formats whether now known or hereafter created,
and to make technical modifications necessary to do so. The
Licensor waives and/or agrees not to assert any right or
authority to forbid You from making technical modifications
necessary to exercise the Licensed Rights, including
technical modifications necessary to circumvent Effective
Technological Measures. For purposes of this Public License,
simply making modifications authorized by this Section 2(a)
(4) never produces Adapted Material.
5. Downstream recipients.
a. Offer from the Licensor -- Licensed Material. Every
recipient of the Licensed Material automatically
receives an offer from the Licensor to exercise the
Licensed Rights under the terms and conditions of this
Public License.
b. No downstream restrictions. You may not offer or impose
any additional or different terms or conditions on, or
apply any Effective Technological Measures to, the
Licensed Material if doing so restricts exercise of the
Licensed Rights by any recipient of the Licensed
Material.
6. No endorsement. Nothing in this Public License constitutes or
may be construed as permission to assert or imply that You
are, or that Your use of the Licensed Material is, connected
with, or sponsored, endorsed, or granted official status by,
the Licensor or others designated to receive attribution as
provided in Section 3(a)(1)(A)(i).
b. Other rights.
1. Moral rights, such as the right of integrity, are not
licensed under this Public License, nor are publicity,
privacy, and/or other similar personality rights; however, to
the extent possible, the Licensor waives and/or agrees not to
assert any such rights held by the Licensor to the limited
extent necessary to allow You to exercise the Licensed
Rights, but not otherwise.
2. Patent and trademark rights are not licensed under this
Public License.
3. To the extent possible, the Licensor waives any right to
collect royalties from You for the exercise of the Licensed
Rights, whether directly or through a collecting society
under any voluntary or waivable statutory or compulsory
licensing scheme. In all other cases the Licensor expressly
reserves any right to collect such royalties.
Section 3 -- License Conditions.
Your exercise of the Licensed Rights is expressly made subject to the
following conditions.
a. Attribution.
1. If You Share the Licensed Material, You must:
a. retain the following if it is supplied by the Licensor
with the Licensed Material:
i. identification of the creator(s) of the Licensed
Material and any others designated to receive
attribution, in any reasonable manner requested by
the Licensor (including by pseudonym if
designated);
ii. a copyright notice;
iii. a notice that refers to this Public License;
iv. a notice that refers to the disclaimer of
warranties;
v. a URI or hyperlink to the Licensed Material to the
extent reasonably practicable;
b. indicate if You modified the Licensed Material and
retain an indication of any previous modifications; and
c. indicate the Licensed Material is licensed under this
Public License, and include the text of, or the URI or
hyperlink to, this Public License.
For the avoidance of doubt, You do not have permission under
this Public License to Share Adapted Material.
2. You may satisfy the conditions in Section 3(a)(1) in any
reasonable manner based on the medium, means, and context in
which You Share the Licensed Material. For example, it may be
reasonable to satisfy the conditions by providing a URI or
hyperlink to a resource that includes the required
information.
3. If requested by the Licensor, You must remove any of the
information required by Section 3(a)(1)(A) to the extent
reasonably practicable.
Section 4 -- Sui Generis Database Rights.
Where the Licensed Rights include Sui Generis Database Rights that
apply to Your use of the Licensed Material:
a. for the avoidance of doubt, Section 2(a)(1) grants You the right
to extract, reuse, reproduce, and Share all or a substantial
portion of the contents of the database, provided You do not Share
Adapted Material;
b. if You include all or a substantial portion of the database
contents in a database in which You have Sui Generis Database
Rights, then the database in which You have Sui Generis Database
Rights (but not its individual contents) is Adapted Material; and
c. You must comply with the conditions in Section 3(a) if You Share
all or a substantial portion of the contents of the database.
For the avoidance of doubt, this Section 4 supplements and does not
replace Your obligations under this Public License where the Licensed
Rights include other Copyright and Similar Rights.
Section 5 -- Disclaimer of Warranties and Limitation of Liability.
a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
c. The disclaimer of warranties and limitation of liability provided
above shall be interpreted in a manner that, to the extent
possible, most closely approximates an absolute disclaimer and
waiver of all liability.
Section 6 -- Term and Termination.
a. This Public License applies for the term of the Copyright and
Similar Rights licensed here. However, if You fail to comply with
this Public License, then Your rights under this Public License
terminate automatically.
b. Where Your right to use the Licensed Material has terminated under
Section 6(a), it reinstates:
1. automatically as of the date the violation is cured, provided
it is cured within 30 days of Your discovery of the
violation; or
2. upon express reinstatement by the Licensor.
For the avoidance of doubt, this Section 6(b) does not affect any
right the Licensor may have to seek remedies for Your violations
of this Public License.
c. For the avoidance of doubt, the Licensor may also offer the
Licensed Material under separate terms or conditions or stop
distributing the Licensed Material at any time; however, doing so
will not terminate this Public License.
d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
License.
Section 7 -- Other Terms and Conditions.
a. The Licensor shall not be bound by any additional or different
terms or conditions communicated by You unless expressly agreed.
b. Any arrangements, understandings, or agreements regarding the
Licensed Material not stated herein are separate from and
independent of the terms and conditions of this Public License.
Section 8 -- Interpretation.
a. For the avoidance of doubt, this Public License does not, and
shall not be interpreted to, reduce, limit, restrict, or impose
conditions on any use of the Licensed Material that could lawfully
be made without permission under this Public License.
b. To the extent possible, if any provision of this Public License is
deemed unenforceable, it shall be automatically reformed to the
minimum extent necessary to make it enforceable. If the provision
cannot be reformed, it shall be severed from this Public License
without affecting the enforceability of the remaining terms and
conditions.
c. No term or condition of this Public License will be waived and no
failure to comply consented to unless expressly agreed to by the
Licensor.
d. Nothing in this Public License constitutes or may be interpreted
as a limitation upon, or waiver of, any privileges and immunities
that apply to the Licensor or You, including from the legal
processes of any jurisdiction or authority.
=======================================================================
Creative Commons is not a party to its public
licenses. Notwithstanding, Creative Commons may elect to apply one of
its public licenses to material it publishes and in those instances
will be considered the “Licensor.” The text of the Creative Commons
public licenses is dedicated to the public domain under the CC0 Public
Domain Dedication. Except for the limited purpose of indicating that
material is shared under a Creative Commons public license or as
otherwise permitted by the Creative Commons policies published at
creativecommons.org/policies, Creative Commons does not authorize the
use of the trademark "Creative Commons" or any other trademark or logo
of Creative Commons without its prior written consent including,
without limitation, in connection with any unauthorized modifications
to any of its public licenses or any other arrangements,
understandings, or agreements concerning use of licensed material. For
the avoidance of doubt, this paragraph does not form part of the
public licenses.
Creative Commons may be contacted at creativecommons.org.

392
static/public/assets/fonts/_canon/CC_BY_ND_4_0_INTERNATIONAL.body.LICENSE
View file

@ -1,392 +0,0 @@
Attribution-NoDerivatives 4.0 International
=======================================================================
Creative Commons Corporation ("Creative Commons") is not a law firm and
does not provide legal services or legal advice. Distribution of
Creative Commons public licenses does not create a lawyer-client or
other relationship. Creative Commons makes its licenses and related
information available on an "as-is" basis. Creative Commons gives no
warranties regarding its licenses, any material licensed under their
terms and conditions, or any related information. Creative Commons
disclaims all liability for damages resulting from their use to the
fullest extent possible.
Using Creative Commons Public Licenses
Creative Commons public licenses provide a standard set of terms and
conditions that creators and other rights holders may use to share
original works of authorship and other material subject to copyright
and certain other rights specified in the public license below. The
following considerations are for informational purposes only, are not
exhaustive, and do not form part of our licenses.
Considerations for licensors: Our public licenses are
intended for use by those authorized to give the public
permission to use material in ways otherwise restricted by
copyright and certain other rights. Our licenses are
irrevocable. Licensors should read and understand the terms
and conditions of the license they choose before applying it.
Licensors should also secure all rights necessary before
applying our licenses so that the public can reuse the
material as expected. Licensors should clearly mark any
material not subject to the license. This includes other CC-
licensed material, or material used under an exception or
limitation to copyright. More considerations for licensors:
wiki.creativecommons.org/Considerations_for_licensors
Considerations for the public: By using one of our public
licenses, a licensor grants the public permission to use the
licensed material under specified terms and conditions. If
the licensor's permission is not necessary for any reason--for
example, because of any applicable exception or limitation to
copyright--then that use is not regulated by the license. Our
licenses grant only permissions under copyright and certain
other rights that a licensor has authority to grant. Use of
the licensed material may still be restricted for other
reasons, including because others have copyright or other
rights in the material. A licensor may make special requests,
such as asking that all changes be marked or described.
Although not required by our licenses, you are encouraged to
respect those requests where reasonable. More considerations
for the public:
wiki.creativecommons.org/Considerations_for_licensees
=======================================================================
Creative Commons Attribution-NoDerivatives 4.0 International Public
License
By exercising the Licensed Rights (defined below), You accept and agree
to be bound by the terms and conditions of this Creative Commons
Attribution-NoDerivatives 4.0 International Public License ("Public
License"). To the extent this Public License may be interpreted as a
contract, You are granted the Licensed Rights in consideration of Your
acceptance of these terms and conditions, and the Licensor grants You
such rights in consideration of benefits the Licensor receives from
making the Licensed Material available under these terms and
conditions.
Section 1 -- Definitions.
a. Adapted Material means material subject to Copyright and Similar
Rights that is derived from or based upon the Licensed Material
and in which the Licensed Material is translated, altered,
arranged, transformed, or otherwise modified in a manner requiring
permission under the Copyright and Similar Rights held by the
Licensor. For purposes of this Public License, where the Licensed
Material is a musical work, performance, or sound recording,
Adapted Material is always produced where the Licensed Material is
synched in timed relation with a moving image.
b. Copyright and Similar Rights means copyright and/or similar rights
closely related to copyright including, without limitation,
performance, broadcast, sound recording, and Sui Generis Database
Rights, without regard to how the rights are labeled or
categorized. For purposes of this Public License, the rights
specified in Section 2(b)(1)-(2) are not Copyright and Similar
Rights.
c. Effective Technological Measures means those measures that, in the
absence of proper authority, may not be circumvented under laws
fulfilling obligations under Article 11 of the WIPO Copyright
Treaty adopted on December 20, 1996, and/or similar international
agreements.
d. Exceptions and Limitations means fair use, fair dealing, and/or
any other exception or limitation to Copyright and Similar Rights
that applies to Your use of the Licensed Material.
e. Licensed Material means the artistic or literary work, database,
or other material to which the Licensor applied this Public
License.
f. Licensed Rights means the rights granted to You subject to the
terms and conditions of this Public License, which are limited to
all Copyright and Similar Rights that apply to Your use of the
Licensed Material and that the Licensor has authority to license.
g. Licensor means the individual(s) or entity(ies) granting rights
under this Public License.
h. Share means to provide material to the public by any means or
process that requires permission under the Licensed Rights, such
as reproduction, public display, public performance, distribution,
dissemination, communication, or importation, and to make material
available to the public including in ways that members of the
public may access the material from a place and at a time
individually chosen by them.
i. Sui Generis Database Rights means rights other than copyright
resulting from Directive 96/9/EC of the European Parliament and of
the Council of 11 March 1996 on the legal protection of databases,
as amended and/or succeeded, as well as other essentially
equivalent rights anywhere in the world.
j. You means the individual or entity exercising the Licensed Rights
under this Public License. Your has a corresponding meaning.
Section 2 -- Scope.
a. License grant.
1. Subject to the terms and conditions of this Public License,
the Licensor hereby grants You a worldwide, royalty-free,
non-sublicensable, non-exclusive, irrevocable license to
exercise the Licensed Rights in the Licensed Material to:
a. reproduce and Share the Licensed Material, in whole or
in part; and
b. produce and reproduce, but not Share, Adapted Material.
2. Exceptions and Limitations. For the avoidance of doubt, where
Exceptions and Limitations apply to Your use, this Public
License does not apply, and You do not need to comply with
its terms and conditions.
3. Term. The term of this Public License is specified in Section
6(a).
4. Media and formats; technical modifications allowed. The
Licensor authorizes You to exercise the Licensed Rights in
all media and formats whether now known or hereafter created,
and to make technical modifications necessary to do so. The
Licensor waives and/or agrees not to assert any right or
authority to forbid You from making technical modifications
necessary to exercise the Licensed Rights, including
technical modifications necessary to circumvent Effective
Technological Measures. For purposes of this Public License,
simply making modifications authorized by this Section 2(a)
(4) never produces Adapted Material.
5. Downstream recipients.
a. Offer from the Licensor -- Licensed Material. Every
recipient of the Licensed Material automatically
receives an offer from the Licensor to exercise the
Licensed Rights under the terms and conditions of this
Public License.
b. No downstream restrictions. You may not offer or impose
any additional or different terms or conditions on, or
apply any Effective Technological Measures to, the
Licensed Material if doing so restricts exercise of the
Licensed Rights by any recipient of the Licensed
Material.
6. No endorsement. Nothing in this Public License constitutes or
may be construed as permission to assert or imply that You
are, or that Your use of the Licensed Material is, connected
with, or sponsored, endorsed, or granted official status by,
the Licensor or others designated to receive attribution as
provided in Section 3(a)(1)(A)(i).
b. Other rights.
1. Moral rights, such as the right of integrity, are not
licensed under this Public License, nor are publicity,
privacy, and/or other similar personality rights; however, to
the extent possible, the Licensor waives and/or agrees not to
assert any such rights held by the Licensor to the limited
extent necessary to allow You to exercise the Licensed
Rights, but not otherwise.
2. Patent and trademark rights are not licensed under this
Public License.
3. To the extent possible, the Licensor waives any right to
collect royalties from You for the exercise of the Licensed
Rights, whether directly or through a collecting society
under any voluntary or waivable statutory or compulsory
licensing scheme. In all other cases the Licensor expressly
reserves any right to collect such royalties.
Section 3 -- License Conditions.
Your exercise of the Licensed Rights is expressly made subject to the
following conditions.
a. Attribution.
1. If You Share the Licensed Material, You must:
a. retain the following if it is supplied by the Licensor
with the Licensed Material:
i. identification of the creator(s) of the Licensed
Material and any others designated to receive
attribution, in any reasonable manner requested by
the Licensor (including by pseudonym if
designated);
ii. a copyright notice;
iii. a notice that refers to this Public License;
iv. a notice that refers to the disclaimer of
warranties;
v. a URI or hyperlink to the Licensed Material to the
extent reasonably practicable;
b. indicate if You modified the Licensed Material and
retain an indication of any previous modifications; and
c. indicate the Licensed Material is licensed under this
Public License, and include the text of, or the URI or
hyperlink to, this Public License.
For the avoidance of doubt, You do not have permission under
this Public License to Share Adapted Material.
2. You may satisfy the conditions in Section 3(a)(1) in any
reasonable manner based on the medium, means, and context in
which You Share the Licensed Material. For example, it may be
reasonable to satisfy the conditions by providing a URI or
hyperlink to a resource that includes the required
information.
3. If requested by the Licensor, You must remove any of the
information required by Section 3(a)(1)(A) to the extent
reasonably practicable.
Section 4 -- Sui Generis Database Rights.
Where the Licensed Rights include Sui Generis Database Rights that
apply to Your use of the Licensed Material:
a. for the avoidance of doubt, Section 2(a)(1) grants You the right
to extract, reuse, reproduce, and Share all or a substantial
portion of the contents of the database, provided You do not Share
Adapted Material;
b. if You include all or a substantial portion of the database
contents in a database in which You have Sui Generis Database
Rights, then the database in which You have Sui Generis Database
Rights (but not its individual contents) is Adapted Material; and
c. You must comply with the conditions in Section 3(a) if You Share
all or a substantial portion of the contents of the database.
For the avoidance of doubt, this Section 4 supplements and does not
replace Your obligations under this Public License where the Licensed
Rights include other Copyright and Similar Rights.
Section 5 -- Disclaimer of Warranties and Limitation of Liability.
a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
c. The disclaimer of warranties and limitation of liability provided
above shall be interpreted in a manner that, to the extent
possible, most closely approximates an absolute disclaimer and
waiver of all liability.
Section 6 -- Term and Termination.
a. This Public License applies for the term of the Copyright and
Similar Rights licensed here. However, if You fail to comply with
this Public License, then Your rights under this Public License
terminate automatically.
b. Where Your right to use the Licensed Material has terminated under
Section 6(a), it reinstates:
1. automatically as of the date the violation is cured, provided
it is cured within 30 days of Your discovery of the
violation; or
2. upon express reinstatement by the Licensor.
For the avoidance of doubt, this Section 6(b) does not affect any
right the Licensor may have to seek remedies for Your violations
of this Public License.
c. For the avoidance of doubt, the Licensor may also offer the
Licensed Material under separate terms or conditions or stop
distributing the Licensed Material at any time; however, doing so
will not terminate this Public License.
d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
License.
Section 7 -- Other Terms and Conditions.
a. The Licensor shall not be bound by any additional or different
terms or conditions communicated by You unless expressly agreed.
b. Any arrangements, understandings, or agreements regarding the
Licensed Material not stated herein are separate from and
independent of the terms and conditions of this Public License.
Section 8 -- Interpretation.
a. For the avoidance of doubt, this Public License does not, and
shall not be interpreted to, reduce, limit, restrict, or impose
conditions on any use of the Licensed Material that could lawfully
be made without permission under this Public License.
b. To the extent possible, if any provision of this Public License is
deemed unenforceable, it shall be automatically reformed to the
minimum extent necessary to make it enforceable. If the provision
cannot be reformed, it shall be severed from this Public License
without affecting the enforceability of the remaining terms and
conditions.
c. No term or condition of this Public License will be waived and no
failure to comply consented to unless expressly agreed to by the
Licensor.
d. Nothing in this Public License constitutes or may be interpreted
as a limitation upon, or waiver of, any privileges and immunities
that apply to the Licensor or You, including from the legal
processes of any jurisdiction or authority.
=======================================================================
Creative Commons is not a party to its public
licenses. Notwithstanding, Creative Commons may elect to apply one of
its public licenses to material it publishes and in those instances
will be considered the “Licensor.” The text of the Creative Commons
public licenses is dedicated to the public domain under the CC0 Public
Domain Dedication. Except for the limited purpose of indicating that
material is shared under a Creative Commons public license or as
otherwise permitted by the Creative Commons policies published at
creativecommons.org/policies, Creative Commons does not authorize the
use of the trademark "Creative Commons" or any other trademark or logo
of Creative Commons without its prior written consent including,
without limitation, in connection with any unauthorized modifications
to any of its public licenses or any other arrangements,
understandings, or agreements concerning use of licensed material. For
the avoidance of doubt, this paragraph does not form part of the
public licenses.
Creative Commons may be contacted at creativecommons.org.

1
static/public/assets/fonts/_canon/CC_BY_ND_4_0_INTERNATIONAL.url
View file

@ -1 +0,0 @@
https://creativecommons.org/licenses/by-nd/4.0/legalcode.txt

97
static/public/assets/fonts/_canon/SIL_OFL_1_1.LICENSE
View file

@ -1,97 +0,0 @@
Copyright (c) <dates>, <Copyright Holder> (<URL|email>),
with Reserved Font Name <Reserved Font Name>.
Copyright (c) <dates>, <additional Copyright Holder> (<URL|email>),
with Reserved Font Name <additional Reserved Font Name>.
Copyright (c) <dates>, <additional Copyright Holder> (<URL|email>).
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
https://openfontlicense.org
-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.
The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.
DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).
"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.
"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.
PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:
1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.
2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.
3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.
5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.
TERMINATION
This license becomes null and void if any of the above conditions are
not met.
DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.

85
static/public/assets/fonts/_canon/SIL_OFL_1_1.body.LICENSE
View file

@ -1,85 +0,0 @@
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.
The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.
DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).
"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.
"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.
PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:
1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.
2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.
3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.
5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.
TERMINATION
This license becomes null and void if any of the above conditions are
not met.
DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.

1
static/public/assets/fonts/_canon/SIL_OFL_1_1.url
View file

@ -1 +0,0 @@
https://openfontlicense.org/documents/OFL.txt

8
static/public/assets/fonts/cormorant/header.LICENSE
View file

@ -1,8 +0,0 @@
Copyright 2015 The Cormorant Project Authors (github.com/CatharsisFonts/Cormorant) CormorantInfant-Italic[wght].ttf: Copyright 2015 The Cormorant Project Authors (github.com/CatharsisFonts/Cormorant)
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL

4
static/public/assets/fonts/fonts.css
View file

@ -45,15 +45,14 @@
src: url("reforma/Reforma1969-Gris.woff2") format("woff2");
font-family: "prose";
font-weight: bold;
size-adjust: 120%;
display: swap;
}
@font-face {
src: url("reforma/Reforma1969-BlancaItalica.woff2") format("woff2");
src: url("prose-italic");
font-family: "prose";
font-style: italic;
size-adjust: 120%;
display: swap;
}
@ -62,6 +61,5 @@
font-family: "prose";
font-weight: bold;
font-style: italic;
size-adjust: 120%;
display: swap;
}

8
static/public/assets/fonts/maven/header.LICENSE
View file

@ -1,8 +0,0 @@
Copyright 2011 The Maven Pro Project Authors (https://github.com/m4rc1e/mavenproFont), with Reserved Font Name "Maven Pro".
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL

1
static/public/assets/fonts/mononoki/LICENSE
View file

@ -92,3 +92,4 @@ INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.

20
static/public/assets/fonts/mononoki/README.md Normal file
View file

@ -0,0 +1,20 @@
# mononoki
> A font for programming and code review.
For a closer look [http://madmalik.github.io/mononoki/](http://madmalik.github.io/mononoki/).
## Features
* Alternate stylistic set with dotted zero, configurable with `ss01`.
## Installation
[Download mononoki.zip](https://github.com/madmalik/mononoki/releases/download/1.6/mononoki.zip) and unpack it.
* [macOS](http://support.apple.com/kb/HT2509), alternatively there is also a [homebrew formula](https://github.com/Homebrew/homebrew-cask/blob/main/Casks/font/font-m/font-mononoki.rb).
* [Windows](https://support.microsoft.com/en-us/office/add-a-font-b7c5f17c-4426-4b53-967f-455339c564c1)
* Linux/Unix - distro dependent, if you have a font manager installed on your system, open the font file and hit "Install". Alternatively, there are [mononoki-packages](https://repology.org/project/fonts:mononoki/versions) in many of the package repos, if you prefer installing via package manager.
## Credit
Box drawing characters created with [box drawing](https://github.com/adobe-type-tools/box-drawing).

9
static/public/assets/fonts/mononoki/header.LICENSE
View file

@ -1,9 +0,0 @@
Copyright (c) 2022, Matthias Tellen matthias.tellen@googlemail.com,
with Reserved Font Name mononoki.
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL

0
static/public/assets/fonts/rawengulk/LICENSE → static/public/assets/fonts/rawengulk/SIL Open Font License.txt
View file

7
static/public/assets/fonts/rawengulk/header.LICENSE
View file

@ -1,7 +0,0 @@
Copyright (c) 2010, gluk (gluksza@wp.pl),
with Reserved Font Name Rawengulk.
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL

0
static/public/assets/fonts/reforma/LICENSE → static/public/assets/fonts/reforma/LICENSE.txt Normal file → Executable file
View file

18
static/public/assets/fonts/reforma/README.txt Executable file
View file

@ -0,0 +1,18 @@
# Reforma
Reforma is a bespoke typeface designed for the Universidad Nacional de Córdoba. The UNC commissioned PampaType to create this typeface as part of the celebrations for the centenary of the University Reform, occurred in this house in 1918. Following Argentina’s national education policy, libre and free, the typeface Reforma is freely available for anyone, under the Creative Commons license BY-ND 4.0 International. This full license is available at: https://creativecommons.org/licenses/by-nd/4.0/
© Copyright 2018 by the Universidad Nacional de Córdoba [AR]. Designed by Alejandro Lo Celso. Programmed by Guido Ferreyra. PampaType font foundry.
http://pampatype.com.
# Changelog
Version 1.000 (Roman and Italic) created 24/04/2018
First release
Versión 1.001 (Roman) creada 07/06/2018
Bug fix on dieresis

6
static/public/assets/fonts/reforma/header.LICENSE
View file

@ -1,6 +0,0 @@
© Copyright 2018 by the Universidad Nacional de Córdoba [AR]. Designed by Alejandro Lo Celso. Programmed by Guido Ferreyra. PampaType font foundry.
http://pampatype.com.
This Font Software is licensed under the Creative Commons BY-ND 4.0. This full license is available at: https://creativecommons.org/licenses/by-nd/4.0/
## creative commons

127
static/public/assets/fonts/split.sh
View file

@ -1,127 +0,0 @@
#!/usr/bin/env sh
set -eu
log() {
printf ' [split] %s\n' "$@" >&2
}
get_marker() {
# extended regex syntax
cc_marker='^\#? ?Attribution-NoDerivatives 4.0 International$'
ofl_marker='^SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007$'
m_file="$1"
if grep -Eq "$ofl_marker" "$m_file"; then
printf '%s' "$ofl_marker"
elif grep -Eq "$cc_marker" "$m_file"; then
printf '%s' "$cc_marker"
else
log "$m_file matches no marker"
printf ''
fi
}
behead() {
b_file="$1"
b_marker="$2"
b_head_out_path="$3"
b_body_out_path="$4"
log "Beheading $b_file on marker $b_marker"
b_body=$(sed -En "/$b_marker/, \$p" "$b_file")
b_head=$(sed -E "/$b_marker/, \$d" "$b_file")
if [ -n "$b_head_out_path" ]; then
log "Keeping head of $b_file on $b_head_out_path"
printf '%s\n' "$b_head" \
| sed -E 's/^-+$//' \
> "$b_head_out_path"
fi
if [ -n "$b_body_out_path" ]; then
log "Keeping body of $b_file on $b_body_out_path"
printf '%s\n' "$b_body" > "$b_body_out_path"
fi
}
compact() {
c_file="$1"
c_marker="$2"
c_out_path="$3"
sed -En "/$c_marker/, \$p" "$c_file" \
| tr -d '[:space:]' \
> "$c_out_path"
}
log "Iterating over font directories"
for dir in *; do
[ -d "$dir" ] || continue
[ "$dir" != _canon ] || continue
license="$dir/LICENSE"; [ -f "$license" ]
log "On license $license"
marker=$(get_marker "$license")
log "Got '$marker' marker for license $license"
if [ -n "$marker" ]; then
behead "$license" "$marker" "$dir/header.LICENSE" ""
compact "$license" "$marker" "$dir/compact.LICENSE"
fi
done
log "Iterating over canonical licenses"
for license in _canon/*.LICENSE; do
printf '%s' "$license" \
| grep -qEv '(header|compact|body)\.LICENSE' \
|| continue
marker=$(get_marker "$license")
log "Got '$marker' marker for license $license"
body_name=$(printf '%s' "$license" | sed "s*\.LICENSE*.body.LICENSE*")
compact_name=$(printf '%s' "$license" | sed "s*\.LICENSE*.compact.LICENSE*")
log "Using names $body_name (body) and $compact_name (compact)"
behead "$license" "$marker" "" "$body_name"
compact "$license" "$marker" "$compact_name"
done
for file in ./*/*LICENSE*; do
size=$(du "$file" | awk '{print $1}')
if [ "$size" -le 0 ]; then
log "$file is empty"
exit 1
fi
done
sha256sum ./*/*LICENSE* > LICENSES.sha256sum
grep compact LICENSES.sha256sum | sort
unique_licenses=$(
find _canon/ \
-name '*.LICENSE' \
-not -name '*.compact.LICENSE' \
-not -name '*.body.LICENSE' \
| wc -l
)
unique_hashes=$(
cat LICENSES.sha256sum \
| grep compact \
| awk '{print $1}' \
| sort \
| uniq \
| wc -l
)
if [ "$unique_hashes" -ne "$unique_licenses" ]; then
log "Number of distinct hashes and licenses don't match."
log "unique hashes: $unique_hashes"
log "unique licenses: $unique_licenses"
exit 1
fi

199
static/public/assets/style.css
View file

@ -1,5 +1,4 @@
:root {
color-scheme: light dark;
--base-font-size: 1em;
}
@ -16,8 +15,6 @@ body {
line-height: 1.75;
box-sizing: border-box;
min-width: 0;
background: light-dark(#eee, #222);
color: light-dark(#000, #f1e9e5);
}
main {
@ -28,13 +25,12 @@ main {
box-sizing: border-box;
}
p:not(.quote-citation), section li {
p, section li {
font-family: prose, sans-serif;
}
section p {
line-height: 2;
margin: 4px 0 16px;
}
pre {
@ -47,78 +43,71 @@ pre {
transition: 1000ms;
}
pre:hover {
box-shadow: 1px 1px 3px 2.5px #00777777;
}
code {
padding: 3px 6px;
margin-right: 3px;
white-space: nowrap;
font-size: calc(var(--base-font-size) * 0.8);
box-shadow: 1px 1px 1px 1px #00000077;
transition: 1000ms;
box-shadow: 1px 1px 0.5px 0.5px #00000077;
}
code:hover {
box-shadow: 1px 1px 1px 1px #00777799;
}
pre, code {
background: light-dark(#e0e0e0, #333);
font-family: mono, monospace;
border: solid 1px light-dark(#d0d0d0, #434343);
background: #e0e0e0;
border: solid 2px #d0d0d0;
border-radius: 6px;
}
h1 , h2 , h3 , h4 , h5 , h6 {
code { font-size: calc(var(--base-font-size) * 0.6); }
a {
color: #0f6366;
text-decoration: underline dotted #138e8e;
text-decoration-thickness: 1.5px;
text-underline-offset: 3px;
}
a {
color: light-dark(#0f6366, #1dd7d7);
text-decoration: underline dotted #159b9b;
text-decoration-thickness: 2.5px;
text-underline-offset: 3px;
a.attached {
transition: 1500ms;
}
a.attached:hover,
#nav-main a:hover
{
color: light-dark(#117c7c, #00ffff);
color: #117c7c;
text-decoration-color: #10afaf;
text-shadow: 0px 0px 22px #10afaf;
transition: 1500ms;
}
a.detached {
color: light-dark(#595959, #acacac);
text-decoration-color: light-dark(#444444, #777);
color: #595959;
text-decoration-color: #444444;
}
a.external {
color: light-dark(#1958a7, #2fbae4);
text-decoration-color: light-dark(#2A7CDF, #46c1e7);
color: #1958a7;
text-decoration-color: #2A7CDF;
text-decoration-style: solid;
text-decoration-thickness: 1.5px;
transition: 1500ms;
}
a.external:hover {
color: light-dark(#037cb2, #74e5ff);
transition: 1500ms;
}
a.absolute {
color: light-dark(#196719, #2fe471);
text-decoration-color: light-dark(#196719, #2fe471);
text-decoration-style: solid;
text-decoration-thickness: 1.5px;
transition: 1500ms;
}
a.absolute:hover {
filter: brightness(1.25);
transition: 1500ms;
color: #0393b2;
text-decoration-color: #1ed4f1;
}
a:visited,
a.detached:visited,
a.external:visited
{
text-decoration-color: light-dark(#bbb, #999);
transition: 1500ms;
text-decoration-color: #999;
}
footer div a {
@ -154,19 +143,18 @@ span.root-label {
span.id-label {
font-family: mono, monospace;
background: light-dark(#e0e0e0, #444);
border: solid 1px light-dark(#d0d0d0, #666);
background: #e0e0e0;
border: solid 1px #d0d0d0;
}
span.unlisted-label {
background: light-dark(#888, #000);
color: light-dark(#eee, #969696);
border: solid 1px light-dark(#d0d0d0, #555);
span.hidden-label {
background: #888;
color: #eee;
border: solid 1px #d0d0d0;
}
h1 {
font-family: title, serif;
line-height: 1;
}
h2, h3, h4, h5, h6 {
@ -179,8 +167,7 @@ main h2 {
h1, h2, h3, h4, h5, h6 {
font-weight: 1;
margin: 10px 0 5px;
overflow-wrap: break-word;
margin: 10px 0;
}
h1.node-title {
@ -197,11 +184,11 @@ h3.connections-title {
}
h1 { font-size: calc(var(--base-font-size) * 3.6); }
h2 { font-size: calc(var(--base-font-size) * 2.8); }
h3 { font-size: calc(var(--base-font-size) * 2.4); }
h4 { font-size: calc(var(--base-font-size) * 2.0); }
h5 { font-size: calc(var(--base-font-size) * 1.6); }
h6 { font-size: calc(var(--base-font-size) * 1.2); }
h2 { font-size: calc(var(--base-font-size) * 3.4); }
h3 { font-size: calc(var(--base-font-size) * 3.0); }
h4 { font-size: calc(var(--base-font-size) * 2.6); }
h5 { font-size: calc(var(--base-font-size) * 2.2); }
h6 { font-size: calc(var(--base-font-size) * 1.8); }
footer div {
margin: 20px 0;
@ -287,8 +274,8 @@ button
border-radius: 5px;
padding: 5px 8px;
margin-right: 3px;
background: light-dark(#eeeeff00, #002020);
border-color: light-dark(#216767, #138e8e);
background: #eeeeff00;
border-color: #216767;
border-width: 0.5px;
transition: 1500ms;
}
@ -298,7 +285,7 @@ input[type="submit"]:hover,
select:hover,
button:hover
{
border-color: light-dark(#36a9a9, #00ffff);
border-color: #36a9a9;
box-shadow: 2px 2px #36a9a9ee;
}
@ -311,6 +298,7 @@ div#error-poem {
}
em, i {
font-style: oblique 20deg;
font-weight: 300;
padding-right: 2px;
}
@ -320,17 +308,11 @@ em#index-node-count {
}
table {
margin: 20px auto;
margin: auto;
border-collapse: collapse;
border: 0.5px dotted #666;
}
table th {
background: light-dark(#099, #002929);
color: #fff;
border-color: light-dark(#222, #666);
}
td, th {
padding: 10px;
border: 0.5px dotted #666;
@ -338,7 +320,6 @@ td, th {
summary {
margin-bottom: 15px;
cursor: pointer;
}
hr {
@ -349,33 +330,77 @@ footer hr {
margin-top: 60px;
}
blockquote {
font-family: serifed;
font-size: calc(var(--base-font-size) * 1.6);
}
p.verse {
font-family: serifed;
font-size: calc(var(--base-font-size) * 1.6);
margin-left: 2em;
}
.quote-citation {
display: block;
margin: 0.5em 0 0 0;
text-indent: -1.2em;
padding-left: 1em;
font-size: calc(var(--base-font-size) * 0.8);
}
.quote-citation::before {
content: "— ";
}
@media (prefers-color-scheme: dark) {
* {
background: #222222;
color: #f1e9e5;
}
pre, code {
background: #333333;
border: solid 1px #434343;
}
a {
color: #1dd7d7;
text-decoration-color: #159b9b;
}
a.attached:hover,
#nav-main a:hover
{
color: #00ffff;
text-decoration-color: #66ffff;
}
a.external {
color: #2fbae4;
text-decoration-color: #46c1e7;
}
a.external:hover {
color: #74e5ff;
text-decoration-color: #aeffff;
}
a.detached {
color: #acacac;
text-decoration-color: #777;
}
span.id-label {
background: #444;
border-color: #666;
}
span.hidden-label {
background: #000;
border-color: #555;
color: #969696;
}
input[type="text"],
input[type="submit"],
select,
button
{
background: #002020;
border-color: #138e8e;
}
input[type="text"]:hover,
input[type="submit"]:hover,
select:hover,
button:hover
{
border-color: #00ffff;
}
span.root-label {
border-width: 1px;
}
}
@media (max-width: 600px) {

19
static/welcome.toml
View file

@ -1,19 +0,0 @@
#:schema ./graph-schema.json
[nodes.GettingStarted]
title = "Getting Started"
text = """
## Welcome to en!
#
If you are seeing this, it's working!
Now that you know how to run it, tell en how to find your graph file by adding a `--graph` option:
`
en --graph my_graph.toml
`
Alternatively, you can also add a `static` directory next to the en binary with a `graph.toml` file in it.
To learn how to write your first graph and everything else about en, check out the |documentation|https://en.jutty.dev|.
"""

12
templates/about.html
View file

@ -8,17 +8,17 @@
{% if graph.meta.config.about_text %}
{{ graph.meta.config.about_text | safe }}
{% else %}
<p>en is a writing instrument to create a connected collection of texts.</p>
<p>en is a program to create a connected collection of texts.</p>
<p>You define your graph using plain-text files, en reads these files and generates a website like the one you are browsing right now.</p>
<p>You define your graph using a plain-text configuration file, en reads this file and generates a website like the one you are browsing right now.</p>
<p>If you'd like to learn more:</p>
<ul>
<li><a href="https://en.jutty.dev/node/Introduction">More about en</a></li>
<li><a href="https://en.jutty.dev/node/GetStarted">Get Started</a></li>
<li><a href="https://en.jutty.dev">Documentation</a></li>
<li><a href="https://codeberg.org/jutty/en">Code repository</a></li>
<li><a href="https://en.jutty.dev">Website</a></li>
<li><a href="https://en.jutty.dev/node/en">More about en</a></li>
<li><a href="https://en.jutty.dev/node/Documentation">Documentation</a></li>
<li><a href="https://codeberg.org/jutty/en">Source code repository</a></li>
</ul>
{% endif %}

Some files were not shown because too many files have changed in this diff Show more