Remove Environment namespace HEAD main

1 files changed, 103 insertions, 4 deletions

diff --git a/src/root.zig b/src/root.zig
index bcc601d..939549f 100644
--- a/src/root.zig
+++ b/src/root.zig
@@ -5,22 +5,24 @@
 const Allocator = std.mem.Allocator;
 const ArgsTuple = std.meta.ArgsTuple;
 const HashMap = std.AutoHashMapUnmanaged;
+const SourceLocation = std.builtin.SourceLocation;
 const assert = std.debug.assert;
 const c_allocator = std.heap.c_allocator;
 const declarations = std.meta.declarations;
 const eql = std.mem.eql;
+const expectEqual = std.testing.expectEqual;
 const expectEqualDeep = std.testing.expectEqualDeep;
+const expectError = std.testing.expectError;
 const std = @import("std");
 const toLower = std.ascii.toLower;
+const zeroes = std.mem.zeroes;
 
-pub const Environment = @import("Environment.zig");
 pub const janet = rename.janet;
 pub const kebabCase = rename.kebabCase;
 const rename = @import("rename.zig");
 pub const renamespace = rename.space;
 
 test {
-    _ = Environment;
     _ = rename;
 }
 
@@ -334,11 +336,108 @@ test "isomorphism" {
     const i = Immutable{};
     try expectEqualDeep(i, try unwrap(Immutable, try wrap(i)));
     const sum = try unwrap(@TypeOf(&Immutable.sum), try wrap(Immutable.sum));
-    try expectEqualDeep(i.sum(), sum(i));
+    try expectEqual(i.sum(), sum(i));
 
     var array: [2]bool = undefined;
     const buffer: []bool = &array;
     buffer[0] = false;
     buffer[1] = true;
-    try expectEqualDeep(buffer, try unwrap(@TypeOf(buffer), try wrap(buffer)));
+    try expectEqual(buffer, try unwrap(@TypeOf(buffer), try wrap(buffer)));
+}
+
+/// Evaluates the Janet program given in str.
+pub fn eval(comptime T: type, str: []const u8, src: [*:0]const u8) !T {
+    var ret: Value = undefined;
+    const errflags = janet.dobytes(janet.coreEnv(null),
+                                   str.ptr, @intCast(str.len), src, &ret);
+    // Errors are already logged by Janet,
+    // among them only one is returned and not machine-readable.
+    return if (errflags == 0) unwrap(T, ret) else error.JanetError;
+}
+
+test eval {
+    init();
+    defer deinit();
+    try expectEqual(try eval(i32, "(+ 3 7)", @src().fn_name), 10);
+}
+
+/// Binds val to name.
+pub fn def(name: [*:0]const u8, val: anytype,
+           documentation: [*:0]const u8) !void {
+    janet.def(janet.coreEnv(null), name, try wrap(val), documentation);
+}
+
+test def {
+    const Number = struct {
+        const Number = @This();
+        n: i8,
+        pub fn nextN(self: Number) Number {
+            return Number{ .n = self.n + 1 };
+        }
+    };
+    init();
+    defer deinit();
+    try def("seven", Number{ .n = 7 }, "number 7 in a struct");
+    const nine = try eval(Number, "(:next-n (:next-n seven))",
+                              @src().fn_name);
+    try expectEqual(Number{ .n = 9 }, nine);
+}
+
+/// Gets value.
+pub fn resolve(T: type, name: []const u8) !T {
+    const symbol = janet.symbol(name.ptr, @intCast(name.len));
+    return try unwrap(T, janet.resolveExt(janet.coreEnv(null), symbol).value);
+}
+
+test resolve {
+    init();
+    defer deinit();
+    try def("pi", 3, "pi for engineers");
+    try expectEqual(try resolve(u8, "pi"), 3);
+}
+
+/// Exposes given function in Janet.
+pub fn defn(comptime fun: anytype, reg: struct {
+    prefix: ?[*:0]const u8 = null,
+    name: [*:0]const u8,
+    documentation: [*:0]const u8,
+    source: SourceLocation,
+}) !void {
+    const cfuns = [_]janet.RegExt{
+        .{
+            .name = reg.name,
+            .cfun = try wrapFn(fun),
+            .documentation = reg.documentation,
+            .source_file = reg.source.file,
+            .source_line = @bitCast(reg.source.line),
+        },
+        zeroes(janet.RegExt),
+    };
+    const env = janet.coreEnv(null);
+    if (reg.prefix) |prefix|
+        janet.cfunsExtPrefix(env, prefix, &cfuns)
+    else
+        janet.cfunsExt(env, null, &cfuns);
+}
+
+test defn {
+    init();
+    defer deinit();
+    try defn(struct {
+        fn add(a: i32, b: i32) i32 { return a + b; }
+    }.add, .{
+        .name = "add",
+        .documentation = "(add a b)\n\nReturn a + b.",
+        .source = @src(),
+    });
+    try expectEqual(try eval(i32, "(add 3 7)", @src().fn_name), 10);
+
+    try defn(struct {
+        fn raise() !void { return error.ThisIsFine; }
+    }.raise, .{
+        .name = "raise",
+        .documentation = "(raise)\n\nRaise an error.",
+        .source = @src(),
+    });
+    try expectError(error.JanetError, eval(void, "(raise)", @src().fn_name));
 }