fenrir-runtime 0.0.1 → 0.3.0

package/src/stdlib/sandbox.js

@@ -0,0 +1,32 @@
+import { print, log, err, warn, info, prompt, readFile, fileExists, readDir, readJSON, get, env, args, exit, cwd, now, time, sleep, bench, range, rand, randInt, pick, shuffle, chunk, unique, flatten, sum, avg, min, max, clamp, capitalize, truncate, pad, repeat, keys, values, entries, merge, clone, all, race, retry, isString, isNumber, isBool, isArray, isObject, isNull, isDefined, abs, ceil, floor, round, sqrt, pow, PI, E, log2, log10, sin, cos, tan, parse, cache, pipe, assert, assertEqual, assertThrows } from './index.js';
+
+const blocked = name => () => { throw new Error(`[sandbox] '${name}' is disabled in sandbox mode`); };
+
+export function injectGlobals() {
+  Object.assign(globalThis, {
+    print, log, err, warn, info, prompt,
+    readFile, fileExists, readDir, readJSON,
+    writeFile:  blocked('writeFile'),
+    appendFile: blocked('appendFile'),
+    writeJSON:  blocked('writeJSON'),
+    mkdir:      blocked('mkdir'),
+    rm:         blocked('rm'),
+    get,
+    post:       blocked('post'),
+    exec:       blocked('exec'),
+    run:        blocked('run'),
+    spawn:      blocked('spawn'),
+    serve:      blocked('serve'),
+    openDb:     blocked('openDb'),
+    env, args, exit, cwd,
+    now, time, sleep, bench,
+    range, rand, randInt, pick, shuffle, chunk, unique, flatten, sum, avg, min, max, clamp,
+    capitalize, truncate, pad, repeat,
+    keys, values, entries, merge, clone,
+    all, race, retry,
+    isString, isNumber, isBool, isArray, isObject, isNull, isDefined,
+    abs, ceil, floor, round, sqrt, pow, PI, E, log2, log10, sin, cos, tan,
+    parse, cache, pipe,
+    assert, assertEqual, assertThrows,
+  });
+}

package/test_fenrir.sh

@@ -0,0 +1,435 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+PASS=0
+FAIL=0
+ERRORS=()
+
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
+pass() { echo -e "  ${GREEN}✓${RESET}  $1"; ((PASS++)); }
+fail() { echo -e "  ${RED}✘${RESET}  $1"; ((FAIL++)); ERRORS+=("$1"); }
+section() { echo -e "\n${BOLD}${CYAN}▸ $1${RESET}"; }
+
+assert_output() {
+  local label="$1" cmd="$2" expected="$3"
+  local actual
+  actual=$(eval "$cmd" 2>&1) || true
+  if echo "$actual" | grep -qF "$expected"; then
+    pass "$label"
+  else
+    fail "$label  (expected: '$expected', got: '$actual')"
+  fi
+  return 0
+}
+
+assert_exit0() {
+  local label="$1" cmd="$2"
+  if eval "$cmd" > /dev/null 2>&1; then
+    pass "$label"
+  else
+    fail "$label  (command failed: $cmd)"
+  fi
+  return 0
+}
+
+assert_file_exists() {
+  local label="$1" file="$2"
+  if [ -f "$file" ]; then pass "$label"; else fail "$label  (missing: $file)"; fi
+  return 0
+}
+
+assert_file_contains() {
+  local label="$1" file="$2" pat="$3"
+  if grep -qF "$pat" "$file" 2>/dev/null; then
+    pass "$label"
+  else
+    fail "$label  (file '$file' missing: '$pat')"
+  fi
+  return 0
+}
+
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+cd "$TMP"
+
+echo -e "\n${BOLD}Fenrir Test Suite${RESET}  ${YELLOW}$(fenrir --version 2>/dev/null)${RESET}"
+echo -e "${YELLOW}Working dir: $TMP${RESET}"
+
+section "Binary"
+assert_exit0   "fenrir binary exists"        "which fenrir"
+assert_output  "fenrir help shows Usage"     "fenrir help" "Run"
+assert_output  "fenrir help shows commands"  "fenrir help" "watch"
+
+section "Run — print"
+cat > hello.fnr << 'FNR'
+print("hello world")
+FNR
+assert_output "print() works" "fenrir hello.fnr" "hello world"
+
+section "Run — f-string interpolation"
+cat > fstr.fnr << 'FNR'
+const name = "Fenrir"
+const n = 42
+print(f"Hello {name}, number {n}")
+FNR
+assert_output "f-string with string var" "fenrir fstr.fnr" "Hello Fenrir"
+assert_output "f-string with number var" "fenrir fstr.fnr" "number 42"
+
+section "Run — fn keyword"
+cat > fn_test.fnr << 'FNR'
+fn add(a, b) {
+  return a + b
+}
+print(add(3, 4))
+FNR
+assert_output "fn keyword → function" "fenrir fn_test.fnr" "7"
+
+section "Run — async fn keyword"
+cat > asyncfn.fnr << 'FNR'
+async fn delay(ms) {
+  await sleep(ms)
+  return "done"
+}
+const r = await delay(10)
+print(r)
+FNR
+assert_output "async fn keyword" "fenrir asyncfn.fnr" "done"
+
+section "Run — pipe operator"
+cat > pipe_test.fnr << 'FNR'
+const double = x => x * 2
+const inc    = x => x + 1
+const result = 5 |> double |> inc
+print(result)
+FNR
+assert_output "pipe operator |>" "fenrir pipe_test.fnr" "11"
+
+section "Run — match / pattern matching"
+cat > match_test.fnr << 'FNR'
+const x = "hello"
+match x {
+  "hello" => print("matched hello")
+  "bye"   => print("matched bye")
+  _       => print("no match")
+}
+FNR
+assert_output "match string arm"   "fenrir match_test.fnr" "matched hello"
+# match default arm - write a separate file
+cat > match_default.fnr << 'MATCHFNR'
+const x = "other"
+match x {
+  "hello" => print("matched hello")
+  _       => print("no match")
+}
+MATCHFNR
+assert_output "match default arm" "fenrir match_default.fnr" "no match"
+
+section "Stdlib — math"
+cat > math_test.fnr << 'FNR'
+print(sum([1,2,3,4,5]))
+print(avg([10,20,30]))
+print(clamp(150, 0, 100))
+print(randInt(1, 1))
+FNR
+assert_output "sum()"    "fenrir math_test.fnr" "15"
+assert_output "avg()"    "fenrir math_test.fnr" "20"
+assert_output "clamp()"  "fenrir math_test.fnr" "100"
+assert_output "randInt(1,1)" "fenrir math_test.fnr" "1"
+
+section "Stdlib — array helpers"
+cat > arr_test.fnr << 'FNR'
+const u = unique([1,2,2,3,3,3])
+print(u.length)
+const fl = flatten([[1,2],[3,[4,5]]])
+print(fl.length)
+print(chunk([1,2,3,4,5,6], 2).length)
+FNR
+assert_output "unique()"  "fenrir arr_test.fnr" "3"
+assert_output "flatten()" "fenrir arr_test.fnr" "5"
+assert_output "chunk()"   "fenrir arr_test.fnr" "3"
+
+section "Stdlib — string helpers"
+cat > str_test.fnr << 'FNR'
+print(capitalize("hello"))
+print(truncate("hello world", 5))
+print(pad("7", 3, "0"))
+FNR
+assert_output "capitalize()" "fenrir str_test.fnr" "Hello"
+assert_output "truncate()"   "fenrir str_test.fnr" "hello..."
+assert_output "pad()"        "fenrir str_test.fnr" "007"
+
+section "Stdlib — file I/O"
+cat > file_test.fnr << 'FNR'
+writeFile("out.txt", "fenrir file test")
+const content = readFile("out.txt")
+print(content)
+print(fileExists("out.txt"))
+FNR
+assert_output "writeFile + readFile" "fenrir file_test.fnr" "fenrir file test"
+assert_output "fileExists()"         "fenrir file_test.fnr" "true"
+
+section "Stdlib — JSON"
+cat > json_test.fnr << 'FNR'
+writeJSON("data.json", { name: "fenrir", version: 3 })
+const j = readJSON("data.json")
+print(j.name)
+print(j.version)
+FNR
+assert_output "writeJSON + readJSON name"    "fenrir json_test.fnr" "fenrir"
+assert_output "writeJSON + readJSON version" "fenrir json_test.fnr" "3"
+
+section "Stdlib — assert"
+cat > assert_pass.fnr << 'FNR'
+assert(1 === 1, "should pass")
+assertEqual([1,2,3], [1,2,3])
+print("asserts ok")
+FNR
+assert_output "assert() pass"      "fenrir assert_pass.fnr" "asserts ok"
+
+cat > assert_fail.fnr << 'FNR'
+assert(false, "intentional failure")
+FNR
+output=$(fenrir assert_fail.fnr 2>&1 || true)
+if echo "$output" | grep -q "intentional failure"; then
+  pass "assert() throws on false"
+else
+  fail "assert() throws on false"
+fi
+
+section "Stdlib — cache"
+cat > cache_test.fnr << 'FNR'
+const c = cache(5000)
+c.set("key", "value")
+print(c.get("key"))
+print(c.has("key"))
+c.del("key")
+print(c.has("key"))
+FNR
+assert_output "cache set/get"  "fenrir cache_test.fnr" "value"
+assert_output "cache has()"    "fenrir cache_test.fnr" "true"
+assert_output "cache del()"    "fenrir cache_test.fnr" "false"
+
+section "Stdlib — pipe()"
+cat > pipefn_test.fnr << 'FNR'
+const process = pipe(
+  x => x * 2,
+  x => x + 10,
+  x => String(x)
+)
+const result = await process(5)
+print(result)
+FNR
+assert_output "pipe() function composition" "fenrir pipefn_test.fnr" "20"
+
+section "Stdlib — parse (CSV)"
+cat > parse_test.fnr << 'FNR'
+const csv = "name,age\nAlice,30\nBob,25"
+const rows = await parse(csv, "csv")
+print(rows[0].name)
+print(rows[1].age)
+FNR
+assert_output "parse() CSV first row"  "fenrir parse_test.fnr" "Alice"
+assert_output "parse() CSV second row" "fenrir parse_test.fnr" "25"
+
+section "Stdlib — parse (JSON auto-detect)"
+cat > parse_json.fnr << 'FNR'
+const data = await parse('{"x":99}')
+print(data.x)
+FNR
+assert_output "parse() auto JSON" "fenrir parse_json.fnr" "99"
+
+section "Stdlib — serve (HTTP)"
+cat > serve_test.fnr << 'FNR'
+const server = serve(19871, req => {
+  if (req.url === "/ping") return "pong"
+  return { body: { ok: true } }
+})
+await sleep(200)
+const r = await get("http://localhost:19871/ping")
+print(r)
+server.close()
+FNR
+assert_output "serve() + get() ping" "fenrir serve_test.fnr" "pong"
+
+section "Stdlib — env / args / cwd"
+cat > env_test.fnr << 'FNR'
+print(typeof env("PATH"))
+print(typeof cwd())
+FNR
+assert_output "env() returns string" "fenrir env_test.fnr" "string"
+assert_output "cwd() returns string" "fenrir env_test.fnr" "string"
+
+section "Stdlib — sleep / now / time"
+cat > time_test.fnr << 'FNR'
+const before = now()
+await sleep(50)
+const after = now()
+print(after > before)
+print(typeof time())
+FNR
+assert_output "sleep() + now() timing" "fenrir time_test.fnr" "true"
+assert_output "time() returns string"   "fenrir time_test.fnr" "string"
+
+section "Stdlib — range / pick / shuffle"
+cat > range_test.fnr << 'FNR'
+const r = range(0, 5)
+print(r.length)
+print(r[0])
+print(r[4])
+FNR
+assert_output "range() length"  "fenrir range_test.fnr" "5"
+assert_output "range() first"   "fenrir range_test.fnr" "0"
+assert_output "range() last"    "fenrir range_test.fnr" "4"
+
+section "Stdlib — type checkers"
+cat > types_test.fnr << 'FNR'
+print(isString("hi"))
+print(isNumber(42))
+print(isArray([]))
+print(isObject({}))
+print(isNull(null))
+print(isDefined(undefined))
+FNR
+assert_output "isString()"  "fenrir types_test.fnr" "true"
+assert_output "isNumber()"  "fenrir types_test.fnr" "true"
+assert_output "isArray()"   "fenrir types_test.fnr" "true"
+assert_output "isObject()"  "fenrir types_test.fnr" "true"
+assert_output "isNull()"    "fenrir types_test.fnr" "true"
+assert_output "isDefined()" "fenrir types_test.fnr" "false"
+
+section "CLI — fmt"
+cat > fmt_test.fnr << 'FNR'
+fn hello() {
+print("hi")
+}
+FNR
+assert_exit0 "fenrir fmt runs without error" "fenrir fmt fmt_test.fnr"
+
+section "CLI — lint"
+cat > lint_test.fnr << 'FNR'
+var x = 1
+console.log(x)
+FNR
+output=$(fenrir lint lint_test.fnr 2>&1)
+if echo "$output" | grep -q "issue"; then
+  pass "fenrir lint detects issues"
+else
+  fail "fenrir lint detects issues"
+fi
+
+section "CLI — bundle"
+cat > entry.fnr << 'FNR'
+print("bundled!")
+FNR
+fenrir bundle entry.fnr bundle_out.mjs > /dev/null 2>&1 || true
+assert_file_exists "fenrir bundle creates output file" "bundle_out.mjs"
+assert_file_contains "bundle output contains user code" "bundle_out.mjs" "bundled!"
+
+section "CLI — test runner"
+cat > sample.test.fnr << 'FNR'
+test("addition works", () => {
+  assertEqual(1 + 1, 2)
+})
+test("string check", () => {
+  assert(isString("hi"), "should be string")
+})
+FNR
+assert_exit0 "fenrir test passes" "fenrir test sample.test.fnr"
+
+cat > fail.test.fnr << 'FNR'
+test("this fails", () => {
+  assertEqual(1, 2)
+})
+FNR
+output=$(fenrir test fail.test.fnr 2>&1 || true)
+if echo "$output" | grep -q "failed"; then
+  pass "fenrir test reports failures"
+else
+  fail "fenrir test reports failures"
+fi
+
+section "CLI — new (scaffold)"
+fenrir new myproject script > /dev/null 2>&1 || true
+assert_file_exists "fenrir new creates main.fnr"    "myproject/main.fnr"
+assert_file_exists "fenrir new creates fenrir.json" "myproject/fenrir.json"
+assert_file_exists "fenrir new creates .gitignore"  "myproject/.gitignore"
+
+section "CLI — doctor"
+output=$(fenrir doctor 2>&1)
+if echo "$output" | grep -q "Node.js"; then
+  pass "fenrir doctor shows Node.js check"
+else
+  fail "fenrir doctor shows Node.js check"
+fi
+
+section "CLI — archive / diff / rollback / clean"
+mkdir -p archtest && cd archtest
+echo "print('v1')" > main.fnr
+fenrir archive "initial" > /dev/null 2>&1
+assert_file_exists "archive creates .fenrir dir" ".fenrir/archives/$(ls .fenrir/archives | head -1)/.metadata.json"
+
+echo "print('v2')" > main.fnr
+fenrir archive "second" > /dev/null 2>&1
+
+output=$(fenrir archives 2>&1)
+if echo "$output" | grep -q "second"; then
+  pass "fenrir archives lists snapshots"
+else
+  fail "fenrir archives lists snapshots"
+fi
+
+output=$(fenrir diff 2>&1)
+if echo "$output" | grep -q "Diff\|No differences\|changed\|Not enough"; then
+  pass "fenrir diff runs"
+else
+  fail "fenrir diff runs"
+fi
+
+fenrir clean 1 > /dev/null 2>&1
+count=$(ls .fenrir/archives | wc -l | tr -d ' ')
+if [ "$count" -le 2 ]; then
+  pass "fenrir clean keeps correct number"
+else
+  fail "fenrir clean keeps correct number (got $count)"
+fi
+cd "$TMP"
+
+section "Sandbox mode"
+cat > sandbox_test.fnr << 'FNR'
+try {
+  writeFile("blocked.txt", "should not write")
+  print("FAIL - should have thrown")
+} catch(e) {
+  print("sandbox blocked write")
+}
+FNR
+assert_output "sandbox blocks writeFile" "fenrir sandbox_test.fnr --sandbox" "sandbox blocked"
+
+section "use import syntax"
+cat > mylib.fnr << 'FNR'
+export const greet = name => f"Hello, {name}!"
+FNR
+cat > use_test.fnr << 'FNR'
+use { greet } from "./mylib.fnr"
+print(greet("world"))
+FNR
+assert_output "use ... from local file" "fenrir use_test.fnr" "Hello, world!"
+
+echo -e "\n${BOLD}─────────────────────────────────────────${RESET}"
+echo -e "${BOLD}Results: ${GREEN}${PASS} passed${RESET}, ${RED}${FAIL} failed${RESET} / $((PASS+FAIL)) total"
+
+if [ ${#ERRORS[@]} -gt 0 ]; then
+  echo -e "\n${RED}Failed tests:${RESET}"
+  for e in "${ERRORS[@]}"; do
+    echo -e "  ${RED}•${RESET} $e"
+  done
+fi
+
+echo ""
+[ $FAIL -eq 0 ] && exit 0 || exit 1

package/App/App.axaml

@@ -1,8 +0,0 @@
-<Application xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             x:Class="FenrirLinux.App"
-             RequestedThemeVariant="Dark">
-    <Application.Styles>
-        <FluentTheme />
-    </Application.Styles>
-</Application>

package/App/App.axaml.cs

@@ -1,23 +0,0 @@
-using Avalonia;
-using Avalonia.Controls.ApplicationLifetimes;
-using Avalonia.Markup.Xaml;
-
-namespace FenrirLinux;
-
-public partial class App : Application
-{
-    public override void Initialize()
-    {
-        AvaloniaXamlLoader.Load(this);
-    }
-
-    public override void OnFrameworkInitializationCompleted()
-    {
-        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
-        {
-            desktop.MainWindow = new MainWindow();
-        }
-
-        base.OnFrameworkInitializationCompleted();
-    }
-}

package/App/FenrirLinux.csproj

@@ -1,27 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
-    <Nullable>enable</Nullable>
-    <BuiltInComInteropSupport>true</BuiltInComInteropSupport>
-    <ApplicationManifest>app.manifest</ApplicationManifest>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <AvaloniaResource Include="Assets\**" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <TrimmerRootDescriptor Include="Roots.xml" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Avalonia" Version="11.0.6" />
-    <PackageReference Include="Avalonia.Desktop" Version="11.0.6" />
-    <PackageReference Include="Avalonia.Themes.Fluent" Version="11.0.6" />
-    <PackageReference Include="Avalonia.Fonts.Inter" Version="11.0.6" />
-    <PackageReference Include="Avalonia.ReactiveUI" Version="11.0.6" />
-    <PackageReference Condition="'$(Configuration)' == 'Debug'" Include="Avalonia.Diagnostics" Version="11.0.6" />
-  </ItemGroup>
-</Project>