@nova-lang/cli 0.1.1 → 0.2.0

package/install.js

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const { execSync, spawnSync } = require("child_process");
-const path = require("path");
-const fs = require("fs");
-
-const ROOT = path.resolve(__dirname);
-const BIN_DIR = path.join(ROOT, "zig-out", "bin");
-const BIN_NAME = process.platform === "win32" ? "nova.exe" : "nova";
-const BIN_PATH = path.join(BIN_DIR, BIN_NAME);
-
-function alreadyBuilt() {
-  try {
-    return fs.statSync(BIN_PATH).isFile();
-  } 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 build() {
-  if (alreadyBuilt()) {
-    console.log("nova: binary already built at " + BIN_PATH);
-    return;
-  }
-
-  const zig = findZig();
-  if (!zig) {
-    console.log(
-      "nova: Zig compiler not found. Skipping build.\n" +
-        "  Install Zig: https://ziglang.org/download/\n" +
-        "  Then run:     npm run build"
-    );
-    return;
-  }
-
-  console.log("nova: building with " + zig + " ...");
-  const result = spawnSync(zig, ["build"], {
-    cwd: ROOT,
-    stdio: "inherit",
-  });
-
-  if (result.status === 0) {
-    console.log("nova: built successfully -> " + BIN_PATH);
-  } else {
-    console.error("nova: build failed (exit code " + result.status + ")");
-    process.exit(result.status ?? 1);
-  }
-}
-
-build();

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,
-            },
-        });
-    }
-};