@nova-lang/cli 0.1.2 → 0.2.0

package/install.js

@@ -1,184 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const { execSync, spawnSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-const https = require("https");
-const { createHash } = require("crypto");
-
-const ROOT = path.resolve(__dirname);
-const BIN_DIR = path.join(ROOT, "bin");
-const PKG = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf-8"));
-const VERSION = PKG.version;
-
-function platform() {
-  const os = process.platform;
-  if (os === "darwin") return "darwin";
-  if (os === "linux") return "linux";
-  if (os === "win32") return "win32";
-  throw new Error("unsupported platform: " + os);
-}
-
-function arch() {
-  const a = process.arch;
-  if (a === "x64") return "x64";
-  if (a === "arm64") return "arm64";
-  throw new Error("unsupported arch: " + a);
-}
-
-function binaryName() {
-  const base = ["nova", platform(), arch()].join("-");
-  return process.platform === "win32" ? base + ".exe" : base;
-}
-
-function binaryPath() {
-  return path.join(BIN_DIR, binaryName());
-}
-
-function binaryExists() {
-  try {
-    return fs.statSync(binaryPath()).isFile();
-  } catch {
-    return false;
-  }
-}
-
-function downloadUrl() {
-  return [
-    "https://github.com/nova-lang/nova/releases/download",
-    "v" + VERSION,
-    binaryName(),
-  ].join("/");
-}
-
-function sha256Url() {
-  return downloadUrl() + ".sha256";
-}
-
-function download(url, dest) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(dest);
-    https
-      .get(url, { timeout: 30000 }, (res) => {
-        if (res.statusCode === 302 || res.statusCode === 301) {
-          file.close();
-          fs.unlinkSync(dest);
-          return download(res.headers.location, dest).then(resolve).catch(reject);
-        }
-        if (res.statusCode !== 200) {
-          file.close();
-          fs.unlinkSync(dest);
-          return reject(new Error("HTTP " + res.statusCode + " for " + url));
-        }
-        res.pipe(file);
-        file.on("finish", () => {
-          file.close();
-          resolve();
-        });
-      })
-      .on("error", (err) => {
-        file.close();
-        try { fs.unlinkSync(dest); } catch {}
-        reject(err);
-      });
-  });
-}
-
-function verifyChecksum(filePath, expectedSha256) {
-  const hash = createHash("sha256");
-  const data = fs.readFileSync(filePath);
-  hash.update(data);
-  return hash.digest("hex") === expectedSha256.trim();
-}
-
-async function downloadBinary() {
-  const url = downloadUrl();
-  const dest = binaryPath();
-  const shaUrl = sha256Url();
-  const shaDest = dest + ".sha256";
-
-  console.log("nova: downloading " + url);
-
-  try {
-    await download(shaUrl, shaDest);
-    const expected = fs.readFileSync(shaDest, "utf-8").split(/\s+/)[0];
-    fs.unlinkSync(shaDest);
-
-    await download(url, dest);
-    fs.chmodSync(dest, 0o755);
-
-    if (!verifyChecksum(dest, expected)) {
-      fs.unlinkSync(dest);
-      throw new Error("sha256 mismatch");
-    }
-
-    console.log("nova: downloaded -> " + dest);
-    return true;
-  } catch (err) {
-    try { fs.unlinkSync(dest); } catch {}
-    try { fs.unlinkSync(shaDest); } catch {}
-    return false;
-  }
-}
-
-function findZig() {
-  try {
-    const r = spawnSync("which", ["zig"], { stdio: "pipe" });
-    if (r.status === 0) return r.stdout.toString().trim();
-  } catch {}
-  try {
-    const r = spawnSync("where", ["zig"], { stdio: "pipe", shell: true });
-    if (r.status === 0) return r.stdout.toString().trim().split("\n")[0];
-  } catch {}
-  return null;
-}
-
-function buildFromSource() {
-  const zig = findZig();
-  if (!zig) {
-    console.log(
-      "nova: no pre-built binary for " + platform() + "-" + arch() + ".\n" +
-      "  Build from source: npm run build  (requires Zig compiler)\n" +
-      "  Or download: https://github.com/nova-lang/nova/releases"
-    );
-    return false;
-  }
-
-  console.log("nova: building from source with " + zig + " ...");
-  const result = spawnSync(zig, ["build", "-Doptimize=ReleaseSafe"], {
-    cwd: ROOT,
-    stdio: "inherit",
-  });
-  if (result.status !== 0) {
-    console.error("nova: build failed");
-    return false;
-  }
-
-  const built = path.join(ROOT, "zig-out", "bin", process.platform === "win32" ? "nova.exe" : "nova");
-  const dest = binaryPath();
-  if (fs.existsSync(built)) {
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.copyFileSync(built, dest);
-    fs.chmodSync(dest, 0o755);
-    console.log("nova: built -> " + dest);
-    return true;
-  }
-  return false;
-}
-
-async function main() {
-  if (binaryExists()) {
-    return;
-  }
-
-  fs.mkdirSync(BIN_DIR, { recursive: true });
-
-  if (await downloadBinary()) return;
-  buildFromSource();
-}
-
-main().catch((err) => {
-  console.error("nova: install error:", err.message);
-  process.exit(1);
-});

package/src/interpreter.zig

@@ -1,288 +0,0 @@
-const std = @import("std");
-const types = @import("types.zig");
-const Node = types.Node;
-
-pub const Env = struct {
-    allocator: std.mem.Allocator,
-    vars: std.StringHashMap([]const u8),
-    macros: std.StringHashMap(types.MacroDef),
-    parent: ?*Env,
-
-    pub fn init(allocator: std.mem.Allocator) Env {
-        return .{
-            .allocator = allocator,
-            .vars = std.StringHashMap([]const u8).init(allocator),
-            .macros = std.StringHashMap(types.MacroDef).init(allocator),
-            .parent = null,
-        };
-    }
-
-    pub fn deinit(self: *Env) void {
-        self.vars.deinit();
-        self.macros.deinit();
-    }
-
-    pub fn get(self: *Env, name: []const u8) ?[]const u8 {
-        if (self.vars.get(name)) |v| return v;
-        if (self.parent) |p| return p.get(name);
-        return null;
-    }
-
-    pub fn set(self: *Env, name: []const u8, value: []const u8) void {
-        self.vars.put(name, value) catch {};
-    }
-
-    pub fn defMacro(self: *Env, name: []const u8, macro: types.MacroDef) void {
-        if (self.parent) |p| {
-            p.defMacro(name, macro);
-        } else {
-            self.macros.put(name, macro) catch {};
-        }
-    }
-
-    pub fn lookupMacro(self: *Env, name: []const u8) ?types.MacroDef {
-        if (self.macros.get(name)) |m| return m;
-        if (self.parent) |p| return p.lookupMacro(name);
-        return null;
-    }
-
-    pub fn clone(self: *Env) !Env {
-        var e = Env.init(self.allocator);
-        e.parent = self;
-        return e;
-    }
-};
-
-pub const Interpreter = struct {
-    allocator: std.mem.Allocator,
-    global_env: Env,
-
-    pub fn init(allocator: std.mem.Allocator) Interpreter {
-        return .{
-            .allocator = allocator,
-            .global_env = Env.init(allocator),
-        };
-    }
-
-    pub fn deinit(self: *Interpreter) void {
-        self.global_env.deinit();
-    }
-
-    pub fn evalDocument(self: *Interpreter, doc: *Node) !Node {
-        const doc_data = &doc.data.document;
-        var new_children = std.ArrayList(Node).init(self.allocator);
-        for (doc_data.children.items) |child| {
-            const result = try self.evalNode(child, &self.global_env);
-            if (result) |n| try new_children.append(n);
-        }
-        doc_data.children = new_children;
-        return doc.*;
-    }
-
-    fn evalNode(self: *Interpreter, node: Node, env: *Env) !?Node {
-        switch (node.tag) {
-            .document => return self.evalDocument(@constCast(&node)),
-            .block => return self.evalBlock(&node.data.block, env),
-            .inline_block => return self.evalInline(&node.data.inline_block, env),
-            .text => return self.evalText(&node.data.text, env),
-            .interpolation => return self.evalInterpolation(&node.data.interpolation, env),
-            .math_inline, .math_display => return node,
-            .list_block => return self.evalList(&node.data.list_block, env),
-            .table_block => return node,
-            .macro_def => {
-                env.defMacro(node.data.macro_def.name, node.data.macro_def);
-                return null;
-            },
-            .schema_def, .service_def => return node,
-            .if_block => return self.evalIf(&node.data.if_block, env),
-            .for_block => return self.evalFor(&node.data.for_block, env),
-            .use_block => {
-                std.debug.print("Warning: @use \"{s}\" is not yet supported (module system not implemented)\n", .{node.data.use_block.path});
-                return null;
-            },
-            .meta_block => return node,
-            else => return node,
-        }
-    }
-
-    fn evalBlock(self: *Interpreter, block: *types.Block, env: *Env) !?Node {
-        if (block.name.len == 0) {
-            block.children = try self.evalChildren(block.children, env);
-            return Node.init(.block, .{ .block = block.* });
-        }
-        const macro = env.lookupMacro(block.name);
-        if (macro) |m| {
-            return self.expandMacro(&m, block, env);
-        }
-        block.children = try self.evalChildren(block.children, env);
-        block.inline_content = try self.evalInlineList(block.inline_content, env);
-        return Node.init(.block, .{ .block = block.* });
-    }
-
-    fn evalInline(self: *Interpreter, inl: *types.InlineBlock, env: *Env) !Node {
-        inl.content = try self.evalInlineList(inl.content, env);
-        return Node.init(.inline_block, .{ .inline_block = inl.* });
-    }
-
-    fn evalText(_: *Interpreter, _text: *types.Text, _: *Env) !Node {
-        return Node.init(.text, .{ .text = _text.* });
-    }
-
-    fn evalInterpolation(_: *Interpreter, interp: *types.Interpolation, _: *Env) !Node {
-        return Node.init(.text, .{ .text = .{ .value = interp.expression } });
-    }
-
-    fn evalChildren(self: *Interpreter, children: std.ArrayList(Node), env: *Env) !std.ArrayList(Node) {
-        var result = std.ArrayList(Node).init(self.allocator);
-        for (children.items) |child| {
-            const evaled = try self.evalNode(child, env);
-            if (evaled) |n| try result.append(n);
-        }
-        return result;
-    }
-
-    fn evalInlineList(self: *Interpreter, nodes: std.ArrayList(Node), env: *Env) !std.ArrayList(Node) {
-        var result = std.ArrayList(Node).init(self.allocator);
-        for (nodes.items) |node| {
-            const evaled = try self.evalNode(node, env);
-            if (evaled) |n| try result.append(n);
-        }
-        return result;
-    }
-
-    fn evalList(self: *Interpreter, list: *types.ListBlock, env: *Env) !Node {
-        var new_items = std.ArrayList(Node).init(self.allocator);
-        for (list.items.items) |item| {
-            if (item.tag == .block) {
-                var blk = item.data.block;
-                blk.children = try self.evalChildren(blk.children, env);
-                try new_items.append(Node.init(.block, .{ .block = blk }));
-            } else {
-                try new_items.append(item);
-            }
-        }
-        list.items = new_items;
-        return Node.init(.list_block, .{ .list_block = list.* });
-    }
-
-    fn evalIf(self: *Interpreter, ifblk: *types.IfBlock, env: *Env) !?Node {
-        const cond = try self.evaluateCondition(ifblk.condition, env);
-        const result = if (cond)
-            try self.evalChildren(ifblk.then_body, env)
-        else
-            try self.evalChildren(ifblk.else_body, env);
-        if (result.items.len == 1) return result.items[0];
-        return Node.init(.document, .{
-            .document = .{
-                .children = result,
-                .meta = std.StringHashMap([]const u8).init(self.allocator),
-            },
-        });
-    }
-
-    fn evalFor(self: *Interpreter, forblk: *types.ForBlock, env: *Env) !?Node {
-        var child_env = try env.clone();
-        var result_nodes = std.ArrayList(Node).init(self.allocator);
-
-        const iterable_val = env.get(forblk.iterable) orelse forblk.iterable;
-        var items = std.ArrayList([]const u8).init(self.allocator);
-        defer items.deinit();
-
-        if (std.mem.eql(u8, forblk.iterable, "true") or std.mem.eql(u8, forblk.iterable, "false") or std.mem.eql(u8, forblk.iterable, "null")) {
-        } else if (std.ascii.isDigit(forblk.iterable[0]) or forblk.iterable[0] == '-') {
-            const count = std.fmt.parseInt(i32, forblk.iterable, 10) catch 1;
-            var i: i32 = 0;
-            while (i < count) : (i += 1) {
-                var buf: [16]u8 = undefined;
-                const val = try std.fmt.bufPrint(&buf, "{}", .{i});
-                try items.append(try self.allocator.dupe(u8, val));
-            }
-        } else {
-            var it = std.mem.splitScalar(u8, iterable_val, ',');
-            while (it.next()) |part| {
-                const trimmed = std.mem.trim(u8, part, " ");
-                if (trimmed.len > 0) try items.append(trimmed);
-            }
-        }
-
-        for (items.items) |item_val| {
-            child_env.set(forblk.var_name, item_val);
-            const evaled = try self.evalChildren(forblk.body, &child_env);
-            for (evaled.items) |n| try result_nodes.append(n);
-        }
-
-        return Node.init(.document, .{
-            .document = .{
-                .children = result_nodes,
-                .meta = std.StringHashMap([]const u8).init(self.allocator),
-            },
-        });
-    }
-
-    fn evaluateCondition(self: *Interpreter, condition: []const u8, env: *Env) !bool {
-        if (condition.len == 0) return true;
-        const trimmed = std.mem.trim(u8, condition, " ");
-        if (std.mem.eql(u8, trimmed, "true")) return true;
-        if (std.mem.eql(u8, trimmed, "false")) return false;
-        if (std.mem.eql(u8, trimmed, "null")) return false;
-        if (std.mem.startsWith(u8, trimmed, "@defined(")) {
-            const inner = std.mem.trim(u8, trimmed["@defined(".len..trimmed.len - 1], " ");
-            return env.get(inner) != null;
-        }
-        if (std.mem.startsWith(u8, trimmed, "!")) {
-            const rest = std.mem.trim(u8, trimmed[1..], " ");
-            return !try self.evaluateCondition(rest, env);
-        }
-        if (env.get(trimmed)) |val| {
-            return !(val.len == 0 or std.mem.eql(u8, val, "false") or std.mem.eql(u8, val, "null"));
-        }
-        const num = std.fmt.parseInt(i32, trimmed, 10) catch return condition.len > 0;
-        return num != 0;
-    }
-
-    fn expandMacro(self: *Interpreter, macro: *types.MacroDef, call: *types.Block, env: *Env) !Node {
-        var child_env = try env.clone();
-
-        var arg_idx: usize = 0;
-        for (macro.params.items) |param_name| {
-            var param_val: []const u8 = "";
-            if (arg_idx < call.inline_content.items.len) {
-                const arg_node = call.inline_content.items[arg_idx];
-                if (arg_node.tag == .text) {
-                    param_val = arg_node.data.text.value;
-                }
-            }
-            child_env.set(param_name, param_val);
-            arg_idx += 1;
-        }
-
-        var kw_iter = macro.kwargs.iterator();
-        while (kw_iter.next()) |entry| {
-            const kw_name = entry.key_ptr.*;
-            const call_val = call.attrs.get(kw_name) orelse entry.value_ptr.*;
-            child_env.set(kw_name, call_val);
-        }
-
-        var evaled_body = std.ArrayList(Node).init(self.allocator);
-        for (macro.body.items) |body_node| {
-            if (body_node.tag == .block and std.mem.eql(u8, body_node.data.block.name, macro.block_param_name) and macro.has_block_param) {
-                for (call.children.items) |call_child| {
-                    const evaled = try self.evalNode(call_child, &child_env);
-                    if (evaled) |n| try evaled_body.append(n);
-                }
-            } else {
-                const evaled = try self.evalNode(body_node, &child_env);
-                if (evaled) |n| try evaled_body.append(n);
-            }
-        }
-
-        return Node.init(.block, .{
-            .block = .{
-                .name = macro.name,
-                .attrs = std.StringHashMap([]const u8).init(self.allocator),
-                .inline_content = std.ArrayList(Node).init(self.allocator),
-                .children = evaled_body,
-            },
-        });
-    }
-};