diff --git a/.gitignore b/.gitignore index f89eb5b..dab555a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,11 @@ zig-out -.zig-cache \ No newline at end of file +.zig-cache + +# Ignore Rust build target directory +vendor/temporal/target + +# But track the specific compiled libraries +!vendor/temporal/target/**/libtemporal.a +!vendor/temporal/target/**/temporal.lib + +tmp \ No newline at end of file diff --git a/build.zig b/build.zig index 9992a09..c55a406 100644 --- a/build.zig +++ b/build.zig @@ -1,156 +1,104 @@ const std = @import("std"); -// Although this function looks imperative, it does not perform the build -// directly and instead it mutates the build graph (`b`) that will be then -// executed by an external runner. The functions in `std.Build` implement a DSL -// for defining build steps and express dependencies between them, allowing the -// build runner to parallelize the build automatically (and the cache system to -// know when a step doesn't need to be re-run). pub fn build(b: *std.Build) void { - // Standard target options allow the person running `zig build` to choose - // what target to build for. Here we do not override the defaults, which - // means any target is allowed, and the default is native. Other options - // for restricting supported target set are available. const target = b.standardTargetOptions(.{}); - // Standard optimization options allow the person running `zig build` to select - // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not - // set a preferred release mode, allowing the user to decide how to optimize. const optimize = b.standardOptimizeOption(.{}); - // It's also possible to define more custom flags to toggle optional features - // of this build script using `b.option()`. All defined flags (including - // target and optimize options) will be listed when running `zig build --help` - // in this directory. - // This creates a module, which represents a collection of source files alongside - // some compilation options, such as optimization mode and linked system libraries. - // Zig modules are the preferred way of making Zig code available to consumers. - // addModule defines a module that we intend to make available for importing - // to our consumers. We must give it a name because a Zig package can expose - // multiple modules and consumers will need to be able to specify which - // module they want to access. const mod = b.addModule("temporalz", .{ - // The root source file is the "entry point" of this module. Users of - // this module will only be able to access public declarations contained - // in this file, which means that if you have declarations that you - // intend to expose to consumers that were defined in other files part - // of this module, you will have to make sure to re-export them from - // the root file. .root_source_file = b.path("src/root.zig"), - // Later on we'll use this module as the root module of a test executable - // which requires us to specify a target. .target = target, }); + mod.addObjectFile(b.path(getTemporalRsPath(target))); - // Here we define an executable. An executable needs to have a root module - // which needs to expose a `main` function. While we could add a main function - // to the module defined above, it's sometimes preferable to split business - // logic and the CLI into two separate modules. - // - // If your goal is to create a Zig library for others to use, consider if - // it might benefit from also exposing a CLI tool. A parser library for a - // data serialization format could also bundle a CLI syntax checker, for example. - // - // If instead your goal is to create an executable, consider if users might - // be interested in also being able to embed the core functionality of your - // program in their own executable in order to avoid the overhead involved in - // subprocessing your CLI tool. - // - // If neither case applies to you, feel free to delete the declaration you - // don't need and to put everything under a single module. const exe = b.addExecutable(.{ .name = "temporalz", .root_module = b.createModule(.{ - // b.createModule defines a new module just like b.addModule but, - // unlike b.addModule, it does not expose the module to consumers of - // this package, which is why in this case we don't have to give it a name. .root_source_file = b.path("src/main.zig"), - // Target and optimization levels must be explicitly wired in when - // defining an executable or library (in the root module), and you - // can also hardcode a specific target for an executable or library - // definition if desireable (e.g. firmware for embedded devices). .target = target, .optimize = optimize, - // List of modules available for import in source files part of the - // root module. .imports = &.{ - // Here "temporalz" is the name you will use in your source code to - // import this module (e.g. `@import("temporalz")`). The name is - // repeated because you are allowed to rename your imports, which - // can be extremely useful in case of collisions (which can happen - // importing modules from different packages). .{ .name = "temporalz", .module = mod }, }, }), }); - - // This declares intent for the executable to be installed into the - // install prefix when running `zig build` (i.e. when executing the default - // step). By default the install prefix is `zig-out/` but can be overridden - // by passing `--prefix` or `-p`. b.installArtifact(exe); - // This creates a top level step. Top level steps have a name and can be - // invoked by name when running `zig build` (e.g. `zig build run`). - // This will evaluate the `run` step rather than the default step. - // For a top level step to actually do something, it must depend on other - // steps (e.g. a Run step, as we will see in a moment). - const run_step = b.step("run", "Run the app"); - - // This creates a RunArtifact step in the build graph. A RunArtifact step - // invokes an executable compiled by Zig. Steps will only be executed by the - // runner if invoked directly by the user (in the case of top level steps) - // or if another step depends on it, so it's up to you to define when and - // how this Run step will be executed. In our case we want to run it when - // the user runs `zig build run`, so we create a dependency link. + // Run command const run_cmd = b.addRunArtifact(exe); - run_step.dependOn(&run_cmd.step); - - // By making the run step depend on the default step, it will be run from the - // installation directory rather than directly from within the cache directory. run_cmd.step.dependOn(b.getInstallStep()); - - // This allows the user to pass arguments to the application in the build - // command itself, like this: `zig build run -- arg1 arg2 etc` if (b.args) |args| { run_cmd.addArgs(args); } + const run_step = b.step("run", "Run the app"); - // Creates an executable that will run `test` blocks from the provided module. - // Here `mod` needs to define a target, which is why earlier we made sure to - // set the releative field. - const mod_tests = b.addTest(.{ - .root_module = mod, - }); + // Tests + { + run_step.dependOn(&run_cmd.step); + const test_step = b.step("test", "Run tests"); + const mod_tests = b.addTest(.{ .root_module = mod }); + test_step.dependOn(&b.addRunArtifact(mod_tests).step); + const exe_tests = b.addTest(.{ .root_module = exe.root_module }); + test_step.dependOn(&b.addRunArtifact(exe_tests).step); + } - // A run step that will run the test executable. - const run_mod_tests = b.addRunArtifact(mod_tests); + // Rust cross-compilation prebuild + { + const rust_prebuild_step = b.step("temporal-rs", "Build and vendor Rust staticlibs for supported targets"); + var rustup_args: [3 + rust_targets.len][]const u8 = undefined; + rustup_args[0] = "rustup"; + rustup_args[1] = "target"; + rustup_args[2] = "add"; + for (rust_targets, 0..) |t, i| { + rustup_args[3 + i] = t.triple; + } + const rustup_add = b.addSystemCommand(&rustup_args); + rust_prebuild_step.dependOn(&rustup_add.step); - // Creates an executable that will run `test` blocks from the executable's - // root module. Note that test executables only test one module at a time, - // hence why we have to create two separate ones. - const exe_tests = b.addTest(.{ - .root_module = exe.root_module, - }); - - // A run step that will run the second test executable. - const run_exe_tests = b.addRunArtifact(exe_tests); - - // A top level step for running all tests. dependOn can be called multiple - // times and since the two run steps do not depend on one another, this will - // make the two of them run in parallel. - const test_step = b.step("test", "Run tests"); - test_step.dependOn(&run_mod_tests.step); - test_step.dependOn(&run_exe_tests.step); - - // Just like flags, top level steps are also listed in the `--help` menu. - // - // The Zig build system is entirely implemented in userland, which means - // that it cannot hook into private compiler APIs. All compilation work - // orchestrated by the build system will result in other Zig compiler - // subcommands being invoked with the right flags defined. You can observe - // these invocations when one fails (or you pass a flag to increase - // verbosity) to validate assumptions and diagnose problems. - // - // Lastly, the Zig build system is relatively simple and self-contained, - // and reading its source code will allow you to master it. + for (rust_targets) |t| { + const cargo_build = b.addSystemCommand(&.{ + "cargo", + "build", + "--release", + "--manifest-path", + "vendor/temporal/Cargo.toml", + "--target", + t.triple, + }); + cargo_build.step.dependOn(&rustup_add.step); + rust_prebuild_step.dependOn(&cargo_build.step); + } + } +} + +// Supported cross-compilation targets +const rust_targets = [_]struct { triple: []const u8 }{ + .{ .triple = "aarch64-apple-darwin" }, + .{ .triple = "x86_64-apple-darwin" }, + .{ .triple = "x86_64-unknown-linux-gnu" }, + .{ .triple = "aarch64-unknown-linux-gnu" }, + .{ .triple = "x86_64-pc-windows-msvc" }, + .{ .triple = "aarch64-pc-windows-msvc" }, +}; + +// Platform-specific Rust library path resolution +fn getTemporalRsPath(target: std.Build.ResolvedTarget) []const u8 { + const arch_tag = target.result.cpu.arch; + return switch (target.result.os.tag) { + .macos => switch (arch_tag) { + .aarch64 => "vendor/temporal/target/aarch64-apple-darwin/release/libtemporal.a", + .x86_64 => "vendor/temporal/target/x86_64-apple-darwin/release/libtemporal.a", + else => @panic("unsupported macOS architecture"), + }, + .linux => switch (arch_tag) { + .x86_64 => "vendor/temporal/target/x86_64-unknown-linux-gnu/release/libtemporal.a", + .aarch64 => "vendor/temporal/target/aarch64-unknown-linux-gnu/release/libtemporal.a", + else => @panic("unsupported Linux architecture"), + }, + .windows => switch (arch_tag) { + .x86_64 => "vendor/temporal/target/x86_64-pc-windows-msvc/release/libtemporal.lib", + .aarch64 => "vendor/temporal/target/aarch64-pc-windows-msvc/release/libtemporal.lib", + else => @panic("unsupported Windows architecture"), + }, + else => @panic("unsupported OS"), + }; } diff --git a/build.zig.zon b/build.zig.zon index 05aa465..ff9d3fd 100644 --- a/build.zig.zon +++ b/build.zig.zon @@ -1,81 +1,13 @@ .{ - // This is the default name used by packages depending on this one. For - // example, when a user runs `zig fetch --save `, this field is used - // as the key in the `dependencies` table. Although the user can choose a - // different name, most users will stick with this provided value. - // - // It is redundant to include "zig" in this name because it is already - // within the Zig package namespace. .name = .temporalz, - // This is a [Semantic Version](https://semver.org/). - // In a future version of Zig it will be used for package deduplication. .version = "0.0.0", - // Together with name, this represents a globally unique package - // identifier. This field is generated by the Zig toolchain when the - // package is first created, and then *never changes*. This allows - // unambiguous detection of one package being an updated version of - // another. - // - // When forking a Zig project, this id should be regenerated (delete the - // field and run `zig build`) if the upstream project is still maintained. - // Otherwise, the fork is *hostile*, attempting to take control over the - // original project's identity. Thus it is recommended to leave the comment - // on the following line intact, so that it shows up in code reviews that - // modify the field. - .fingerprint = 0xd8d79d59acc4faae, // Changing this has security and trust implications. - // Tracks the earliest Zig version that the package considers to be a - // supported use case. + .fingerprint = 0xd8d79d59acc4faae, .minimum_zig_version = "0.15.2", - // This field is optional. - // Each dependency must either provide a `url` and `hash`, or a `path`. - // `zig build --fetch` can be used to fetch all dependencies of a package, recursively. - // Once all dependencies are fetched, `zig build` no longer requires - // internet connectivity. - .dependencies = .{ - // See `zig fetch --save ` for a command-line interface for adding dependencies. - //.example = .{ - // // When updating this field to a new URL, be sure to delete the corresponding - // // `hash`, otherwise you are communicating that you expect to find the old hash at - // // the new URL. If the contents of a URL change this will result in a hash mismatch - // // which will prevent zig from using it. - // .url = "https://example.com/foo.tar.gz", - // - // // This is computed from the file contents of the directory of files that is - // // obtained after fetching `url` and applying the inclusion rules given by - // // `paths`. - // // - // // This field is the source of truth; packages do not come from a `url`; they - // // come from a `hash`. `url` is just one of many possible mirrors for how to - // // obtain a package matching this `hash`. - // // - // // Uses the [multihash](https://multiformats.io/multihash/) format. - // .hash = "...", - // - // // When this is provided, the package is found in a directory relative to the - // // build root. In this case the package's hash is irrelevant and therefore not - // // computed. This field and `url` are mutually exclusive. - // .path = "foo", - // - // // When this is set to `true`, a package is declared to be lazily - // // fetched. This makes the dependency only get fetched if it is - // // actually used. - // .lazy = false, - //}, - }, - // Specifies the set of files and directories that are included in this package. - // Only files and directories listed here are included in the `hash` that - // is computed for this package. Only files listed here will remain on disk - // when using the zig package manager. As a rule of thumb, one should list - // files required for compilation plus any license(s). - // Paths are relative to the build root. Use the empty string (`""`) to refer to - // the build root itself. - // A directory listed here means that all files within, recursively, are included. + .dependencies = .{}, .paths = .{ "build.zig", "build.zig.zon", "src", - // For example... - //"LICENSE", - //"README.md", + "vendor", }, } diff --git a/src/Instant.zig b/src/Instant.zig new file mode 100644 index 0000000..bf0be06 --- /dev/null +++ b/src/Instant.zig @@ -0,0 +1,572 @@ +const std = @import("std"); + +pub const Instant = @This(); + +inner: *CInstant, +epoch: i64, + +/// Construct from epoch milliseconds (Temporal.Instant.fromEpochMilliseconds). +pub fn init(epoch_ms: i64) !Instant { + return fromEpochMilliseconds(epoch_ms); +} + +/// Construct from epoch milliseconds. +pub fn fromEpochMilliseconds(epoch_ms: i64) !Instant { + return wrapInstant(temporal_rs_Instant_from_epoch_milliseconds(epoch_ms)); +} + +/// Construct from epoch nanoseconds (Temporal.Instant.fromEpochNanoseconds). +pub fn fromEpochNanoseconds(epoch_ns: i128) !Instant { + const parts = i128ToParts(epoch_ns); + return wrapInstant(temporal_rs_Instant_try_new(parts)); +} + +/// Parse an ISO 8601 string (Temporal.Instant.from). +pub fn fromUtf8(text: []const u8) !Instant { + const view = DiplomatStringView{ .data = text.ptr, .len = text.len }; + return wrapInstant(temporal_rs_Instant_from_utf8(view)); +} + +/// Parse an ISO 8601 UTF-16 string (Temporal.Instant.from). +pub fn fromUtf16(text: []const u16) !Instant { + const view = DiplomatString16View{ .data = text.ptr, .len = text.len }; + return wrapInstant(temporal_rs_Instant_from_utf16(view)); +} + +/// Add a Duration to this instant (Temporal.Instant.prototype.add). +pub fn add(self: Instant, duration: *const Duration) !Instant { + return wrapInstant(temporal_rs_Instant_add(self.inner, duration)); +} + +/// Subtract a Duration from this instant (Temporal.Instant.prototype.subtract). +pub fn subtract(self: Instant, duration: *const Duration) !Instant { + return wrapInstant(temporal_rs_Instant_subtract(self.inner, duration)); +} + +/// Difference until another instant (Temporal.Instant.prototype.until). +pub fn until(self: Instant, other: Instant, settings: DifferenceSettings) !DurationHandle { + return wrapDuration(temporal_rs_Instant_until(self.inner, other.inner, settings)); +} + +/// Difference since another instant (Temporal.Instant.prototype.since). +pub fn since(self: Instant, other: Instant, settings: DifferenceSettings) !DurationHandle { + return wrapDuration(temporal_rs_Instant_since(self.inner, other.inner, settings)); +} + +/// Round this instant (Temporal.Instant.prototype.round). +pub fn round(self: Instant, options: RoundingOptions) !Instant { + return wrapInstant(temporal_rs_Instant_round(self.inner, options)); +} + +/// Compare two instants (Temporal.Instant.compare). +pub fn compare(a: Instant, b: Instant) i8 { + return temporal_rs_Instant_compare(a.inner, b.inner); +} + +/// Equality check (Temporal.Instant.prototype.equals). +pub fn equals(a: Instant, b: Instant) bool { + return temporal_rs_Instant_equals(a.inner, b.inner); +} + +/// Epoch milliseconds accessor (Temporal.Instant.prototype.epochMilliseconds). +pub fn epochMilliseconds(self: Instant) i64 { + return temporal_rs_Instant_epoch_milliseconds(self.inner); +} + +/// Epoch nanoseconds accessor (Temporal.Instant.prototype.epochNanoseconds). +pub fn epochNanoseconds(self: Instant) i128 { + const value = temporal_rs_Instant_epoch_nanoseconds(self.inner); + return partsToI128(value); +} + +/// Convert to string using compiled TZ data; caller owns returned slice. +pub fn toString(self: Instant, allocator: std.mem.Allocator, opts: ToStringOptions) ![]u8 { + const zone_opt = if (opts.time_zone) |z| + TimeZone_option{ .ok = z, .is_ok = true } + else + TimeZone_option{ .ok = undefined, .is_ok = false }; + + const rounding = opts.rounding orelse defaultToStringRoundingOptions(); + + const writer = diplomat_buffer_write_create(128); + defer diplomat_buffer_write_destroy(writer); + + const res = temporal_rs_Instant_to_ixdtf_string_with_compiled_data(self.inner, zone_opt, rounding, writer); + try handleVoidResult(res); + + const len = diplomat_buffer_write_len(writer); + const source = diplomat_buffer_write_get_bytes(writer)[0..len]; + + const out = try allocator.alloc(u8, len); + std.mem.copyForwards(u8, out, source); + return out; +} + +/// Convert to string using an explicit provider. +pub fn toStringWithProvider(self: Instant, allocator: std.mem.Allocator, provider: *const Provider, opts: ToStringOptions) ![]u8 { + const zone_opt = if (opts.time_zone) |z| + TimeZone_option{ .ok = z, .is_ok = true } + else + TimeZone_option{ .ok = undefined, .is_ok = false }; + + const rounding = opts.rounding orelse defaultToStringRoundingOptions(); + + const writer = diplomat_buffer_write_create(128); + defer diplomat_buffer_write_destroy(writer); + + const res = temporal_rs_Instant_to_ixdtf_string_with_provider(self.inner, zone_opt, rounding, provider, writer); + try handleVoidResult(res); + + const len = diplomat_buffer_write_len(writer); + const source = diplomat_buffer_write_get_bytes(writer)[0..len]; + + const out = try allocator.alloc(u8, len); + std.mem.copyForwards(u8, out, source); + return out; +} + +/// Convert to ZonedDateTime using built-in provider (Temporal.Instant.prototype.toZonedDateTimeISO). +pub fn toZonedDateTimeIso(self: Instant, zone: TimeZone) !ZonedDateTimeHandle { + return wrapZonedDateTime(temporal_rs_Instant_to_zoned_date_time_iso(self.inner, zone)); +} + +/// Convert to ZonedDateTime using an explicit provider. +pub fn toZonedDateTimeIsoWithProvider(self: Instant, zone: TimeZone, provider: *const Provider) !ZonedDateTimeHandle { + return wrapZonedDateTime(temporal_rs_Instant_to_zoned_date_time_iso_with_provider(self.inner, zone, provider)); +} + +/// Clone the underlying instant. +pub fn clone(self: Instant) Instant { + const ptr = temporal_rs_Instant_clone(self.inner); + return .{ .inner = ptr, .epoch = temporal_rs_Instant_epoch_milliseconds(ptr) }; +} + +pub fn deinit(self: Instant) void { + temporal_rs_Instant_destroy(self.inner); +} + +// --- Helpers ----------------------------------------------------------------- + +fn wrapInstant(res: InstantResult) !Instant { + if (!res.is_ok) return error.TemporalError; + const ptr = res.result.ok orelse return error.TemporalError; + return .{ .inner = ptr, .epoch = temporal_rs_Instant_epoch_milliseconds(ptr) }; +} + +fn wrapDuration(res: DurationResult) !DurationHandle { + if (!res.is_ok) return error.TemporalError; + const ptr = res.result.ok orelse return error.TemporalError; + return .{ .ptr = ptr }; +} + +fn wrapZonedDateTime(res: ZonedDateTimeResult) !ZonedDateTimeHandle { + if (!res.is_ok) return error.TemporalError; + const ptr = res.result.ok orelse return error.TemporalError; + return .{ .ptr = ptr }; +} + +fn handleVoidResult(res: VoidResult) !void { + if (!res.is_ok) return error.TemporalError; +} + +fn i128ToParts(value: i128) I128Nanoseconds { + const is_neg = value < 0; + const mag: u128 = if (is_neg) @intCast(@as(u128, @intCast(-value))) else @intCast(value); + const mask: u64 = 1 << 63; + var high: u64 = @intCast(mag >> 64); + const low: u64 = @intCast(mag & 0xffff_ffff_ffff_ffff); + if (is_neg) high |= mask; + return .{ .high = high, .low = low }; +} + +fn partsToI128(value: I128Nanoseconds) i128 { + const mask: u64 = 1 << 63; + const is_neg = (value.high & mask) != 0; + const mag: u128 = ((@as(u128, value.high & ~mask)) << 64) | value.low; + if (is_neg) return -@as(i128, @intCast(mag)); + return @as(i128, @intCast(mag)); +} + +fn defaultPrecision() Precision { + return .{ .is_minute = false, .precision = OptionU8{ .ok = 0, .is_ok = false } }; +} + +fn defaultToStringRoundingOptions() ToStringRoundingOptions { + return .{ + .precision = defaultPrecision(), + .smallest_unit = Unit_option{ .ok = .Unit_Auto, .is_ok = false }, + .rounding_mode = RoundingMode_option{ .ok = .RoundingMode_Trunc, .is_ok = false }, + }; +} + +fn parseDuration(text: []const u8) !DurationHandle { + const view = DiplomatStringView{ .data = text.ptr, .len = text.len }; + const res = temporal_rs_Duration_from_utf8(view); + if (!res.is_ok) return error.TemporalError; + const ptr = res.result.ok orelse return error.TemporalError; + return .{ .ptr = ptr }; +} + +// --- Public helper types ----------------------------------------------------- + +pub const ToStringOptions = struct { + time_zone: ?TimeZone = null, + rounding: ?ToStringRoundingOptions = null, +}; + +pub const DurationHandle = struct { + ptr: *Duration, + + pub fn deinit(self: DurationHandle) void { + temporal_rs_Duration_destroy(self.ptr); + } +}; + +pub const ZonedDateTimeHandle = struct { + ptr: *ZonedDateTime, + + pub fn deinit(self: ZonedDateTimeHandle) void { + temporal_rs_ZonedDateTime_destroy(self.ptr); + } +}; + +// --- Extern types ------------------------------------------------------------ + +const CInstant = opaque {}; +pub const Duration = opaque {}; +pub const ZonedDateTime = opaque {}; +pub const Provider = opaque {}; + +pub const I128Nanoseconds = extern struct { high: u64, low: u64 }; +pub const I128Nanoseconds_option = extern struct { ok: I128Nanoseconds, is_ok: bool }; + +pub const DiplomatStringView = extern struct { data: [*c]const u8, len: usize }; +pub const DiplomatString16View = extern struct { data: [*c]const u16, len: usize }; + +pub const OptionStringView = extern struct { ok: DiplomatStringView, is_ok: bool }; +pub const OptionU8 = extern struct { ok: u8, is_ok: bool }; +pub const OptionU32 = extern struct { ok: u32, is_ok: bool }; + +pub const DiplomatWrite = extern struct { + context: ?*anyopaque, + buf: [*c]u8, + len: usize, + cap: usize, + grow_failed: bool, + flush: ?*const fn (*DiplomatWrite) void, + grow: ?*const fn (*DiplomatWrite, usize) bool, +}; + +pub const TimeZone = extern struct { + offset_minutes: i16, + resolved_id: usize, + normalized_id: usize, + is_iana_id: bool, +}; + +pub const TimeZone_option = extern struct { + ok: TimeZone, + is_ok: bool, +}; + +pub const Precision = extern struct { + is_minute: bool, + precision: OptionU8, +}; + +pub const Unit = enum(c_int) { + Unit_Auto = 0, + Unit_Nanosecond = 1, + Unit_Microsecond = 2, + Unit_Millisecond = 3, + Unit_Second = 4, + Unit_Minute = 5, + Unit_Hour = 6, + Unit_Day = 7, + Unit_Week = 8, + Unit_Month = 9, + Unit_Year = 10, +}; + +pub const Unit_option = extern struct { ok: Unit, is_ok: bool }; + +pub const RoundingMode = enum(c_int) { + RoundingMode_Ceil = 0, + RoundingMode_Floor = 1, + RoundingMode_Expand = 2, + RoundingMode_Trunc = 3, + RoundingMode_HalfCeil = 4, + RoundingMode_HalfFloor = 5, + RoundingMode_HalfExpand = 6, + RoundingMode_HalfTrunc = 7, + RoundingMode_HalfEven = 8, +}; + +pub const RoundingMode_option = extern struct { ok: RoundingMode, is_ok: bool }; + +pub const DifferenceSettings = extern struct { + largest_unit: Unit_option, + smallest_unit: Unit_option, + rounding_mode: RoundingMode_option, + increment: OptionU32, +}; + +pub const RoundingOptions = extern struct { + largest_unit: Unit_option, + smallest_unit: Unit_option, + rounding_mode: RoundingMode_option, + increment: OptionU32, +}; + +pub const ToStringRoundingOptions = extern struct { + precision: Precision, + smallest_unit: Unit_option, + rounding_mode: RoundingMode_option, +}; + +pub const ErrorKind = enum(c_int) { + ErrorKind_Generic = 0, + ErrorKind_Type = 1, + ErrorKind_Range = 2, + ErrorKind_Syntax = 3, + ErrorKind_Assert = 4, +}; + +pub const TemporalError = extern struct { + kind: ErrorKind, + msg: OptionStringView, +}; + +pub const Sign = enum(c_int) { + Sign_Positive = 1, + Sign_Zero = 0, + Sign_Negative = -1, +}; + +// --- Result wrappers --------------------------------------------------------- + +const InstantResult = extern struct { + result: extern union { + ok: ?*CInstant, + err: TemporalError, + }, + is_ok: bool, +}; + +const DurationResult = extern struct { + result: extern union { + ok: ?*Duration, + err: TemporalError, + }, + is_ok: bool, +}; + +const DurationParseResult = extern struct { + result: extern union { + ok: ?*Duration, + err: TemporalError, + }, + is_ok: bool, +}; + +const ZonedDateTimeResult = extern struct { + result: extern union { + ok: ?*ZonedDateTime, + err: TemporalError, + }, + is_ok: bool, +}; + +const VoidResult = extern struct { + result: extern union { + err: TemporalError, + }, + is_ok: bool, +}; + +// --- Extern functions ------------------------------------------------------- + +extern "c" fn temporal_rs_Instant_try_new(ns: I128Nanoseconds) InstantResult; +extern "c" fn temporal_rs_Instant_from_epoch_milliseconds(epoch_milliseconds: i64) InstantResult; +extern "c" fn temporal_rs_Instant_from_utf8(s: DiplomatStringView) InstantResult; +extern "c" fn temporal_rs_Instant_from_utf16(s: DiplomatString16View) InstantResult; +extern "c" fn temporal_rs_Instant_add(self: *const CInstant, duration: *const Duration) InstantResult; +extern "c" fn temporal_rs_Instant_subtract(self: *const CInstant, duration: *const Duration) InstantResult; +extern "c" fn temporal_rs_Instant_since(self: *const CInstant, other: *const CInstant, settings: DifferenceSettings) DurationResult; +extern "c" fn temporal_rs_Instant_until(self: *const CInstant, other: *const CInstant, settings: DifferenceSettings) DurationResult; +extern "c" fn temporal_rs_Instant_round(self: *const CInstant, options: RoundingOptions) InstantResult; +extern "c" fn temporal_rs_Instant_compare(self: *const CInstant, other: *const CInstant) i8; +extern "c" fn temporal_rs_Instant_equals(self: *const CInstant, other: *const CInstant) bool; +extern "c" fn temporal_rs_Instant_epoch_milliseconds(self: *const CInstant) i64; +extern "c" fn temporal_rs_Instant_epoch_nanoseconds(self: *const CInstant) I128Nanoseconds; +extern "c" fn temporal_rs_Instant_to_ixdtf_string_with_compiled_data(self: *const CInstant, zone: TimeZone_option, options: ToStringRoundingOptions, write: *DiplomatWrite) VoidResult; +extern "c" fn temporal_rs_Instant_to_ixdtf_string_with_provider(self: *const CInstant, zone: TimeZone_option, options: ToStringRoundingOptions, p: *const Provider, write: *DiplomatWrite) VoidResult; +extern "c" fn temporal_rs_Instant_to_zoned_date_time_iso(self: *const CInstant, zone: TimeZone) ZonedDateTimeResult; +extern "c" fn temporal_rs_Instant_to_zoned_date_time_iso_with_provider(self: *const CInstant, zone: TimeZone, p: *const Provider) ZonedDateTimeResult; +extern "c" fn temporal_rs_Instant_clone(self: *const CInstant) *CInstant; +extern "c" fn temporal_rs_Instant_destroy(self: *CInstant) void; + +extern "c" fn temporal_rs_Duration_destroy(self: *Duration) void; +extern "c" fn temporal_rs_Duration_from_utf8(s: DiplomatStringView) DurationParseResult; +extern "c" fn temporal_rs_Duration_hours(self: *const Duration) i64; +extern "c" fn temporal_rs_Duration_minutes(self: *const Duration) i64; +extern "c" fn temporal_rs_Duration_seconds(self: *const Duration) i64; +extern "c" fn temporal_rs_Duration_milliseconds(self: *const Duration) i64; +extern "c" fn temporal_rs_Duration_microseconds(self: *const Duration) f64; +extern "c" fn temporal_rs_Duration_nanoseconds(self: *const Duration) f64; +extern "c" fn temporal_rs_Duration_sign(self: *const Duration) Sign; +extern "c" fn temporal_rs_ZonedDateTime_destroy(self: *ZonedDateTime) void; + +extern "c" fn diplomat_buffer_write_create(cap: usize) *DiplomatWrite; +extern "c" fn diplomat_buffer_write_get_bytes(write: *DiplomatWrite) [*c]u8; +extern "c" fn diplomat_buffer_write_len(write: *DiplomatWrite) usize; +extern "c" fn diplomat_buffer_write_destroy(write: *DiplomatWrite) void; + +// --- Tests ------------------------------------------------------------------- + +test "instant epoch milliseconds roundtrip" { + const epoch_ms: i64 = 1_704_067_200_000; // 2024-01-01T00:00:00Z + const inst = try Instant.init(epoch_ms); + defer inst.deinit(); + + try std.testing.expectEqual(epoch_ms, inst.epochMilliseconds()); +} + +test "instant epoch nanoseconds bounds" { + // The Rust implementation accepts values within the 100M-day window (inclusive). + const max_ns: i128 = 8_640_000_000_000_000_000_000; + const min_ns: i128 = -max_ns; + + const max_inst = try Instant.fromEpochNanoseconds(max_ns); + defer max_inst.deinit(); + const min_inst = try Instant.fromEpochNanoseconds(min_ns); + defer min_inst.deinit(); + + try std.testing.expectEqual(max_ns, max_inst.epochNanoseconds()); + try std.testing.expectEqual(min_ns, min_inst.epochNanoseconds()); + + try std.testing.expectError(error.TemporalError, Instant.fromEpochNanoseconds(max_ns + 1)); + try std.testing.expectError(error.TemporalError, Instant.fromEpochNanoseconds(min_ns - 1)); +} + +test "instant parse utf8" { + const inst = try Instant.fromUtf8("2024-03-15T14:30:45.123Z"); + defer inst.deinit(); + + try std.testing.expectEqual(@as(i64, 1_710_513_045_123), inst.epochMilliseconds()); +} + +test "instant parse utf16" { + const utf8 = "2024-03-15T14:30:45.123Z"; + const allocator = std.testing.allocator; + const utf16 = try std.unicode.utf8ToUtf16LeAlloc(allocator, utf8); + defer allocator.free(utf16); + + const inst = try Instant.fromUtf16(utf16); + defer inst.deinit(); + + try std.testing.expectEqual(@as(i64, 1_710_513_045_123), inst.epochMilliseconds()); +} + +test "instant add subtract duration" { + const base = try Instant.fromEpochMilliseconds(0); + defer base.deinit(); + + var dur = try parseDuration("PT1H30M"); + defer dur.deinit(); + + const added = try base.add(dur.ptr); + defer added.deinit(); + try std.testing.expectEqual(@as(i64, 5_400_000), added.epochMilliseconds()); + + const subbed = try added.subtract(dur.ptr); + defer subbed.deinit(); + try std.testing.expectEqual(@as(i64, 0), subbed.epochMilliseconds()); +} + +test "instant compare and equals" { + const a = try Instant.fromEpochMilliseconds(0); + defer a.deinit(); + const b = try Instant.fromEpochMilliseconds(0); + defer b.deinit(); + const c = try Instant.fromEpochMilliseconds(1_000); + defer c.deinit(); + + try std.testing.expectEqual(@as(i8, 0), Instant.compare(a, b)); + try std.testing.expect(Instant.equals(a, b)); + try std.testing.expectEqual(@as(i8, -1), Instant.compare(a, c)); + try std.testing.expectEqual(@as(i8, 1), Instant.compare(c, a)); +} + +test "instant until and since basic" { + const earlier = try Instant.fromEpochMilliseconds(0); + defer earlier.deinit(); + const later = try Instant.fromEpochMilliseconds(3_600_000); + defer later.deinit(); + + const settings = DifferenceSettings{ + .largest_unit = Unit_option{ .ok = .Unit_Hour, .is_ok = true }, + .smallest_unit = Unit_option{ .ok = .Unit_Second, .is_ok = true }, + .rounding_mode = RoundingMode_option{ .ok = .RoundingMode_Trunc, .is_ok = true }, + .increment = OptionU32{ .ok = 0, .is_ok = false }, + }; + + var until_handle = try earlier.until(later, settings); + defer until_handle.deinit(); + try std.testing.expectEqual(Sign.Sign_Positive, temporal_rs_Duration_sign(until_handle.ptr)); + try std.testing.expectEqual(@as(i64, 1), temporal_rs_Duration_hours(until_handle.ptr)); + + var since_handle = try later.since(earlier, settings); + defer since_handle.deinit(); + try std.testing.expectEqual(Sign.Sign_Positive, temporal_rs_Duration_sign(since_handle.ptr)); + try std.testing.expectEqual(@as(i64, 1), temporal_rs_Duration_hours(since_handle.ptr)); +} + +test "instant round to second" { + const inst = try Instant.fromEpochNanoseconds(1_609_459_245_123_456_789); + defer inst.deinit(); + + const opts = RoundingOptions{ + .largest_unit = Unit_option{ .ok = .Unit_Auto, .is_ok = false }, + .smallest_unit = Unit_option{ .ok = .Unit_Second, .is_ok = true }, + .rounding_mode = RoundingMode_option{ .ok = .RoundingMode_HalfExpand, .is_ok = true }, + .increment = OptionU32{ .ok = 0, .is_ok = false }, + }; + + const rounded = try inst.round(opts); + defer rounded.deinit(); + + const ns = rounded.epochNanoseconds(); + try std.testing.expectEqual(@as(i128, 1_609_459_245_000_000_000), ns); +} + +test "instant clone preserves epoch" { + const inst = try Instant.fromEpochMilliseconds(42); + defer inst.deinit(); + + const cloned = inst.clone(); + defer cloned.deinit(); + + try std.testing.expectEqual(inst.epochMilliseconds(), cloned.epochMilliseconds()); +} + +test "instant toString produces output" { + const inst = try Instant.fromEpochMilliseconds(0); + defer inst.deinit(); + + const allocator = std.testing.allocator; + const out = try inst.toString(allocator, .{}); + defer allocator.free(out); + try std.testing.expect(out.len > 0); +} + +test toString { + const epoch_ms: i64 = 1704067200000; // 2024-01-01 00:00:00 UTC + const inst = try Instant.init(epoch_ms); + defer inst.deinit(); + + const allocator = std.testing.allocator; + const instant_str = try inst.toString(allocator, .{}); + defer allocator.free(instant_str); + try std.testing.expect(instant_str.len > 0); +} diff --git a/src/main.zig b/src/main.zig index c2cb3ed..1ad95ca 100644 --- a/src/main.zig +++ b/src/main.zig @@ -1,27 +1,15 @@ const std = @import("std"); -const temporalz = @import("temporalz"); +const Temporal = @import("temporalz"); pub fn main() !void { - // Prints to stderr, ignoring potential errors. - std.debug.print("All your {s} are belong to us.\n", .{"codebase"}); - try temporalz.bufferedPrint(); -} + const result = try Temporal.Instant.init(1704067200000); // 2024-01-01 00:00:00 UTC + defer result.deinit(); -test "simple test" { - const gpa = std.testing.allocator; - var list: std.ArrayList(i32) = .empty; - defer list.deinit(gpa); // Try commenting this out and see if zig detects the memory leak! - try list.append(gpa, 42); - try std.testing.expectEqual(@as(i32, 42), list.pop()); -} + std.debug.print("Instant with Epoch: {}ms\n", .{result.epoch}); -test "fuzz example" { - const Context = struct { - fn testOne(context: @This(), input: []const u8) anyerror!void { - _ = context; - // Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case! - try std.testing.expect(!std.mem.eql(u8, "canyoufindme", input)); - } - }; - try std.testing.fuzz(Context{}, Context.testOne, .{}); + const cloned = result.clone(); + std.debug.print("Is Instant Equal: {}\n", .{cloned.equals(result)}); + + const instant_str = try cloned.toString(std.heap.page_allocator, .{}); + std.debug.print("Cloned Instant String: {s}\n", .{instant_str}); } diff --git a/src/root.zig b/src/root.zig index 94c7cd0..258b70a 100644 --- a/src/root.zig +++ b/src/root.zig @@ -1,23 +1,31 @@ -//! By convention, root.zig is the root source file when making a library. const std = @import("std"); +pub const Instant = @import("Instant.zig"); -pub fn bufferedPrint() !void { - // Stdout is for the actual output of your application, for example if you - // are implementing gzip, then only the compressed bytes should be sent to - // stdout, not any debugging messages. - var stdout_buffer: [1024]u8 = undefined; - var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer); - const stdout = &stdout_writer.interface; +test "Instant.methods" { + const instant = @import("Instant.zig"); - try stdout.print("Run `zig build test` to run the tests.\n", .{}); + const checks = .{ + .{ .name = "add", .expect = true }, + .{ .name = "equals", .expect = true }, + .{ .name = "round", .expect = true }, + .{ .name = "since", .expect = true }, + .{ .name = "subtract", .expect = true }, + .{ .name = "toString", .expect = true }, + .{ .name = "toZonedDateTimeIso", .expect = true }, + .{ .name = "until", .expect = true }, - try stdout.flush(); // Don't forget to flush! -} - -pub fn add(a: i32, b: i32) i32 { - return a + b; -} - -test "basic add functionality" { - try std.testing.expect(add(3, 7) == 10); + // Not yet implemented aliases from the Temporal JS API. + .{ .name = "toJSON", .expect = false }, + .{ .name = "toLocaleString", .expect = false }, + .{ .name = "valueOf", .expect = false }, + .{ .name = "toZonedDateTimeISO", .expect = false }, // different casing + }; + + inline for (checks) |check| { + const has = @hasDecl(instant, check.name); + if (check.expect) + try std.testing.expect(has) + else + try std.testing.expect(!has); + } }