add implicit cast from [0]T to %[]T

closes #347

also add std.os.path.relative

2 files changed, 101 insertions, 2 deletions

diff --git a/std/mem.zig b/std/mem.zig
index 6a2d854fc7..b82ae8b08d 100644
--- a/std/mem.zig
+++ b/std/mem.zig
@@ -10,8 +10,10 @@ error NoMem;
 pub const Allocator = struct {
     allocFn: fn (self: &Allocator, n: usize) -> %[]u8,
     /// Note that old_mem may be a slice of length 0, in which case reallocFn
-    /// should simply call allocFn
+    /// should simply call allocFn.
     reallocFn: fn (self: &Allocator, old_mem: []u8, new_size: usize) -> %[]u8,
+    /// Note that mem may be a slice of length 0, in which case freeFn
+    /// should do nothing.
     freeFn: fn (self: &Allocator, mem: []u8),
 
     /// Aborts the program if an allocation fails.
@@ -228,6 +230,10 @@ pub fn eql_slice_u8(a: []const u8, b: []const u8) -> bool {
     return eql(u8, a, b);
 }
 
+/// Returns an iterator that iterates over the slices of ::s that are not
+/// the byte ::c.
+/// split("   abc def    ghi  ")
+/// Will return slices for "abc", "def", "ghi", null, in that order.
 pub fn split(s: []const u8, c: u8) -> SplitIterator {
     SplitIterator {
         .index = 0,
@@ -236,6 +242,14 @@ pub fn split(s: []const u8, c: u8) -> SplitIterator {
     }
 }
 
+test "mem.split" {
+    var it = split("   abc def   ghi  ", ' ');
+    assert(eql(u8, ??it.next(), "abc"));
+    assert(eql(u8, ??it.next(), "def"));
+    assert(eql(u8, ??it.next(), "ghi"));
+    assert(it.next() == null);
+}
+
 pub fn startsWith(comptime T: type, haystack: []const T, needle: []const T) -> bool {
     return if (needle.len > haystack.len) false else eql(T, haystack[0...needle.len], needle);
 }
@@ -259,6 +273,14 @@ const SplitIterator = struct {
 
         return self.s[start...end];
     }
+
+    /// Returns a slice of the remaining bytes. Does not affect iterator state.
+    pub fn rest(self: &const SplitIterator) -> []const u8 {
+        // move to beginning of token
+        var index: usize = self.index;
+        while (index < self.s.len and self.s[index] == self.c; index += 1) {}
+        return self.s[index...];
+    }
 };
 
 test "testStringEquality" {
diff --git a/std/os/path.zig b/std/os/path.zig
index 32188b75bc..9b86efe509 100644
--- a/std/os/path.zig
+++ b/std/os/path.zig
@@ -3,8 +3,16 @@ const assert = debug.assert;
 const mem = @import("../mem.zig");
 const Allocator = mem.Allocator;
 const os = @import("index.zig");
+const math = @import("../math.zig");
 
-pub const sep = '/';
+pub const sep = switch (@compileVar("os")) {
+    Os.windows => '\\',
+    else => '/',
+};
+pub const delimiter = switch (@compileVar("os")) {
+    Os.windows => ';',
+    else => ':',
+};
 
 /// Naively combines a series of paths with the native path seperator.
 /// Allocates memory for the result, which must be freed by the caller.
@@ -134,6 +142,7 @@ test "os.path.resolve" {
     assert(mem.eql(u8, testResolve("/a/b", "c", "//d", "e///"), "/d/e"));
     assert(mem.eql(u8, testResolve("/a/b/c", "..", "../"), "/a"));
     assert(mem.eql(u8, testResolve("/", "..", ".."), "/"));
+    assert(mem.eql(u8, testResolve("/a/b/c/"), "/a/b/c"));
 }
 fn testResolve(args: ...) -> []u8 {
     return %%resolve(&debug.global_allocator, args);
@@ -175,3 +184,71 @@ test "os.path.dirname" {
 fn testDirname(input: []const u8, expected_output: []const u8) {
     assert(mem.eql(u8, dirname(input), expected_output));
 }
+
+/// Returns the relative path from ::from to ::to. If ::from and ::to each
+/// resolve to the same path (after calling ::resolve on each), a zero-length
+/// string is returned.
+pub fn relative(allocator: &Allocator, from: []const u8, to: []const u8) -> %[]u8 {
+    const resolved_from = %return resolve(allocator, from);
+    defer allocator.free(resolved_from);
+
+    const resolved_to = %return resolve(allocator, to);
+    defer allocator.free(resolved_to);
+
+    var from_it = mem.split(resolved_from, '/');
+    var to_it = mem.split(resolved_to, '/');
+    while (true) {
+        const from_component = from_it.next() ?? return mem.dupe(allocator, u8, to_it.rest());
+        const to_rest = to_it.rest();
+        test(to_it.next()) |to_component| {
+            if (mem.eql(u8, from_component, to_component))
+                continue;
+        }
+        var up_count: usize = 1;
+        while (true) {
+            _ = from_it.next() ?? break;
+            up_count += 1;
+        }
+        const up_index_end = up_count * "../".len;
+        const result = %return allocator.alloc(u8, up_index_end + to_rest.len);
+        %defer allocator.free(result);
+
+        var result_index: usize = 0;
+        while (result_index < up_index_end) {
+            result[result_index] = '.';
+            result_index += 1;
+            result[result_index] = '.';
+            result_index += 1;
+            result[result_index] = '/';
+            result_index += 1;
+        }
+        if (to_rest.len == 0) {
+            // shave off the trailing slash
+            return result[0...result_index - 1];
+        }
+
+        mem.copy(u8, result[result_index...], to_rest);
+        return result;
+    }
+
+    return []u8{};
+}
+
+test "os.path.relative" {
+    testRelative("/var/lib", "/var", "..");
+    testRelative("/var/lib", "/bin", "../../bin");
+    testRelative("/var/lib", "/var/lib", "");
+    testRelative("/var/lib", "/var/apache", "../apache");
+    testRelative("/var/", "/var/lib", "lib");
+    testRelative("/", "/var/lib", "var/lib");
+    testRelative("/foo/test", "/foo/test/bar/package.json", "bar/package.json");
+    testRelative("/Users/a/web/b/test/mails", "/Users/a/web/b", "../..");
+    testRelative("/foo/bar/baz-quux", "/foo/bar/baz", "../baz");
+    testRelative("/foo/bar/baz", "/foo/bar/baz-quux", "../baz-quux");
+    testRelative("/baz-quux", "/baz", "../baz");
+    testRelative("/baz", "/baz-quux", "../baz-quux");
+}
+fn testRelative(from: []const u8, to: []const u8, expected_output: []const u8) {
+    const result = %%relative(&debug.global_allocator, from, to);
+    assert(mem.eql(u8, result, expected_output));
+}