946 lines
38 KiB
Zig
946 lines
38 KiB
Zig
const std = @import("std");
|
||
const types = @import("../weather/types.zig");
|
||
|
||
fn degreeToArrow(deg: f32) []const u8 {
|
||
const normalized = @mod(deg + 22.5, 360.0);
|
||
const idx: usize = @intFromFloat(normalized / 45.0);
|
||
const arrows = [_][]const u8{ "↓", "↙", "←", "↖", "↑", "↗", "→", "↘" };
|
||
return arrows[@min(idx, 7)];
|
||
}
|
||
|
||
pub const Format = enum {
|
||
plain_text,
|
||
ansi,
|
||
html,
|
||
};
|
||
|
||
fn countInvisible(bytes: []const u8, format: Format) usize {
|
||
var count: usize = 0;
|
||
var i: usize = 0;
|
||
|
||
switch (format) {
|
||
.plain_text => for (bytes) |byte| { // Count multi-byte UTF-8 continuation bytes
|
||
if (byte & 0xC0 == 0x80) count += 1;
|
||
},
|
||
.ansi => while (i < bytes.len) {
|
||
if (bytes[i] == '\x1b' and i + 1 < bytes.len and bytes[i + 1] == '[') {
|
||
const start = i;
|
||
i += 2;
|
||
while (i < bytes.len and bytes[i] != 'm') : (i += 1) {}
|
||
if (i < bytes.len) i += 1;
|
||
count += i - start;
|
||
} else {
|
||
// Also count UTF-8 continuation bytes
|
||
if (bytes[i] & 0xC0 == 0x80) count += 1;
|
||
i += 1;
|
||
}
|
||
},
|
||
.html => while (i < bytes.len) {
|
||
if (bytes[i] == '<') {
|
||
const start = i;
|
||
while (i < bytes.len and bytes[i] != '>') : (i += 1) {}
|
||
if (i < bytes.len) i += 1;
|
||
count += i - start;
|
||
} else {
|
||
// Also count UTF-8 continuation bytes
|
||
if (bytes[i] & 0xC0 == 0x80) count += 1;
|
||
i += 1;
|
||
}
|
||
},
|
||
}
|
||
|
||
return count;
|
||
}
|
||
|
||
pub const RenderOptions = struct {
|
||
narrow: bool = false,
|
||
days: u8 = 3,
|
||
use_imperial: bool = false,
|
||
no_caption: bool = false,
|
||
format: Format = .ansi,
|
||
};
|
||
|
||
pub fn render(allocator: std.mem.Allocator, data: types.WeatherData, options: RenderOptions) ![]const u8 {
|
||
var output = std.Io.Writer.Allocating.init(allocator);
|
||
defer output.deinit();
|
||
|
||
const w = &output.writer;
|
||
if (!options.no_caption)
|
||
try w.print("Weather report: {s}\n\n", .{data.location});
|
||
|
||
try renderCurrent(w, data.current, options);
|
||
|
||
const days_to_show = @min(options.days, data.forecast.len);
|
||
if (days_to_show > 0) {
|
||
try w.writeAll("\n");
|
||
for (data.forecast[0..days_to_show]) |day| {
|
||
try renderForecastDay(w, day, options);
|
||
}
|
||
}
|
||
|
||
return output.toOwnedSlice();
|
||
}
|
||
|
||
fn renderCurrent(w: *std.Io.Writer, current: types.CurrentCondition, options: RenderOptions) !void {
|
||
const temp = if (options.use_imperial) current.tempFahrenheit() else current.temp_c;
|
||
const feels_like = if (options.use_imperial) current.feelsLikeFahrenheit() else current.feels_like_c;
|
||
const temp_unit = if (options.use_imperial) "°F" else "°C";
|
||
const wind_unit = if (options.use_imperial) "mph" else "km/h";
|
||
const wind_speed = if (options.use_imperial) current.windMph() else current.wind_kph;
|
||
const precip_unit = if (options.use_imperial) "in" else "mm";
|
||
const precip = if (options.use_imperial) current.precip_mm * 0.0393701 else current.precip_mm;
|
||
|
||
const art = getWeatherArt(current.weather_code);
|
||
const sign: u8 = if (temp >= 0) '+' else '-';
|
||
const abs_temp = @abs(temp);
|
||
const fl_sign: u8 = if (feels_like >= 0) '+' else '-';
|
||
const abs_fl = @abs(feels_like);
|
||
|
||
switch (options.format) {
|
||
.plain_text => {
|
||
try w.print("{s} {s}\n", .{ art[0], current.condition });
|
||
try w.print("{s} {c}{d:.0}({c}{d:.0}) {s}\n", .{ art[1], sign, abs_temp, fl_sign, abs_fl, temp_unit });
|
||
try w.print("{s} {s} {d:.0} {s}\n", .{ art[2], degreeToArrow(current.wind_deg), wind_speed, wind_unit });
|
||
if (current.visibility_km) |_| {
|
||
const visibility = if (options.use_imperial) current.visiblityMph().? else current.visibility_km.?;
|
||
const vis_unit = if (options.use_imperial) "mi" else "km";
|
||
try w.print("{s} {d:.0} {s}\n", .{ art[3], visibility, vis_unit });
|
||
} else {
|
||
try w.print("{s}\n", .{std.mem.trimRight(u8, art[3], " ")});
|
||
}
|
||
try w.print("{s} {d:.1} {s}\n", .{ art[4], precip, precip_unit });
|
||
},
|
||
.ansi => {
|
||
const temp_color_code = tempColor(current.temp_c);
|
||
const wind_color_code = windColor(current.wind_kph);
|
||
const cloud_color = "\x1b[38;5;250m";
|
||
const reset = "\x1b[0m";
|
||
|
||
try w.print("{s}{s}{s} {s}\n", .{ cloud_color, art[0], reset, current.condition });
|
||
try w.print("{s}{s}{s} \x1b[38;5;{d}m{c}{d:.0}({c}{d:.0}){s} {s}\n", .{ cloud_color, art[1], reset, temp_color_code, sign, abs_temp, fl_sign, abs_fl, reset, temp_unit });
|
||
try w.print("{s}{s}{s} {s} \x1b[38;5;{d}m{d:.0}{s} {s}\n", .{ cloud_color, art[2], reset, degreeToArrow(current.wind_deg), wind_color_code, wind_speed, reset, wind_unit });
|
||
if (current.visibility_km) |_| {
|
||
const visibility = if (options.use_imperial) current.visiblityMph().? else current.visibility_km.?;
|
||
const vis_unit = if (options.use_imperial) "mi" else "km";
|
||
try w.print("{s}{s}{s} {d:.0} {s}\n", .{ cloud_color, art[3], reset, visibility, vis_unit });
|
||
} else {
|
||
try w.print("{s}{s}{s}\n", .{ cloud_color, std.mem.trimRight(u8, art[3], " "), reset });
|
||
}
|
||
try w.print("{s}{s}{s} {d:.1} {s}\n", .{ cloud_color, art[4], reset, precip, precip_unit });
|
||
},
|
||
.html => {
|
||
const temp_color = ansiToHex(tempColor(current.temp_c));
|
||
const wind_color = ansiToHex(windColor(current.wind_kph));
|
||
const cloud_color = "#bcbcbc"; // 250
|
||
|
||
try w.print("<span style=\"color:{s}\">{s}</span> {s}\n", .{ cloud_color, art[0], current.condition });
|
||
try w.print("<span style=\"color:{s}\">{s}</span> <span style=\"color:{s}\">{c}{d:.0}({c}{d:.0})</span> {s}\n", .{ cloud_color, art[1], temp_color, sign, abs_temp, fl_sign, abs_fl, temp_unit });
|
||
try w.print("<span style=\"color:{s}\">{s}</span> {s} <span style=\"color:{s}\">{d:.0}</span> {s}\n", .{ cloud_color, art[2], degreeToArrow(current.wind_deg), wind_color, wind_speed, wind_unit });
|
||
if (current.visibility_km) |_| {
|
||
const visibility = if (options.use_imperial) current.visiblityMph().? else current.visibility_km.?;
|
||
const vis_unit = if (options.use_imperial) "mi" else "km";
|
||
try w.print("<span style=\"color:{s}\">{s}</span> {d:.0} {s}\n", .{ cloud_color, art[3], visibility, vis_unit });
|
||
} else {
|
||
try w.print("<span style=\"color:{s}\">{s}</span>\n", .{ cloud_color, std.mem.trimRight(u8, art[3], " ") });
|
||
}
|
||
try w.print("<span style=\"color:{s}\">{s}</span> {d:.1} {s}\n", .{ cloud_color, art[4], precip, precip_unit });
|
||
},
|
||
}
|
||
}
|
||
|
||
fn renderForecastDay(w: *std.Io.Writer, day: types.ForecastDay, options: RenderOptions) !void {
|
||
var date_str: [11]u8 = undefined;
|
||
if (day.hourly.len < 4) {
|
||
const max_temp = if (options.use_imperial) day.maxTempFahrenheit() else day.max_temp_c;
|
||
const min_temp = if (options.use_imperial) day.minTempFahrenheit() else day.min_temp_c;
|
||
const temp_unit = if (options.use_imperial) "°F" else "°C";
|
||
const art = getWeatherArt(day.weather_code);
|
||
|
||
_ = try formatDate(day.date, .compressed, &date_str);
|
||
try w.print("\n{s}\n", .{std.mem.trimEnd(u8, date_str[0..], " ")});
|
||
try w.print("{s} {s}\n", .{ art[0], day.condition });
|
||
try w.print("{s} {d:.0}{s} / {d:.0}{s}\n", .{ art[1], max_temp, temp_unit, min_temp, temp_unit });
|
||
try w.print("{s}\n", .{std.mem.trimRight(u8, art[2], " ")});
|
||
try w.print("{s}\n", .{std.mem.trimRight(u8, art[3], " ")});
|
||
try w.print("{s}\n", .{std.mem.trimRight(u8, art[4], " ")});
|
||
return;
|
||
}
|
||
|
||
const formatted_date = try formatDate(day.date, .justified, &date_str);
|
||
try w.writeAll(" ┌─────────────┐\n");
|
||
try w.print("┌──────────────────────────────┬───────────────────────┤ {s} ├───────────────────────┬──────────────────────────────┐\n", .{
|
||
std.mem.trimEnd(u8, formatted_date, " "),
|
||
});
|
||
try w.writeAll("│ Morning │ Noon └──────┬──────┘ Evening │ Night │\n");
|
||
try w.writeAll("├──────────────────────────────┼──────────────────────────────┼──────────────────────────────┼──────────────────────────────┤\n");
|
||
|
||
for (0..5) |line| {
|
||
try w.writeAll("│ ");
|
||
for (day.hourly[0..4], 0..) |hour, i| {
|
||
try renderHourlyCell(w, hour, line, options);
|
||
if (i < 3) {
|
||
try w.writeAll(" │ ");
|
||
} else {
|
||
try w.writeAll(" │");
|
||
}
|
||
}
|
||
try w.writeAll("\n");
|
||
}
|
||
|
||
try w.writeAll("└──────────────────────────────┴──────────────────────────────┴──────────────────────────────┴──────────────────────────────┘\n");
|
||
}
|
||
|
||
fn renderHourlyCell(w: *std.Io.Writer, hour: types.HourlyForecast, line: usize, options: RenderOptions) !void {
|
||
const Line = enum(u8) {
|
||
condition = 0,
|
||
temperature = 1,
|
||
wind = 2,
|
||
visibility = 3,
|
||
precipitation = 4,
|
||
};
|
||
|
||
const art = getWeatherArt(hour.weather_code);
|
||
|
||
const total_width = 28;
|
||
const art_width = 14; // includes spacer between art and data. This is display width, not actual
|
||
var buf: [64]u8 = undefined; // We need more than total_width because total_width is display width, not bytes
|
||
var cell_writer = std.Io.Writer.fixed(&buf);
|
||
const cw = &cell_writer;
|
||
|
||
switch (options.format) {
|
||
.ansi => {
|
||
try w.print("\x1b[38;5;250m{s}\x1b[0m ", .{art[line]});
|
||
},
|
||
.html => {
|
||
try w.print("<span style=\"color:#bcbcbc\">{s}</span> ", .{art[line]});
|
||
},
|
||
.plain_text => {
|
||
try w.print("{s} ", .{art[line]});
|
||
},
|
||
}
|
||
|
||
switch (@as(Line, @enumFromInt(line))) {
|
||
.condition => {
|
||
try cw.writeAll(hour.condition);
|
||
},
|
||
.temperature => {
|
||
const temp = if (options.use_imperial) hour.tempFahrenheit() else hour.temp_c;
|
||
const feels_like = if (options.use_imperial) hour.feelsLikeFahrenheit() else hour.feels_like_c;
|
||
const temp_unit = if (options.use_imperial) "°F" else "°C";
|
||
const sign: u8 = if (temp >= 0) '+' else '-';
|
||
const abs_temp = @abs(temp);
|
||
const fl_sign: u8 = if (feels_like >= 0) '+' else '-';
|
||
const abs_fl = @abs(feels_like);
|
||
switch (options.format) {
|
||
.ansi => {
|
||
const color = tempColor(hour.temp_c);
|
||
try cw.print("\x1b[38;5;{d}m{c}{d:.0}({c}{d:.0})\x1b[0m {s}", .{
|
||
color,
|
||
sign,
|
||
abs_temp,
|
||
fl_sign,
|
||
abs_fl,
|
||
temp_unit,
|
||
});
|
||
},
|
||
.html => {
|
||
const color = ansiToHex(tempColor(hour.temp_c));
|
||
try cw.print("<span style=\"color:{s}\">{c}{d:.0}({c}{d:.0})</span> {s}", .{
|
||
color,
|
||
sign,
|
||
abs_temp,
|
||
fl_sign,
|
||
abs_fl,
|
||
temp_unit,
|
||
});
|
||
},
|
||
.plain_text => {
|
||
try cw.print("{c}{d:.0}({c}{d:.0}) {s}", .{ sign, abs_temp, fl_sign, abs_fl, temp_unit });
|
||
},
|
||
}
|
||
},
|
||
.wind => {
|
||
const wind_speed = if (options.use_imperial) hour.windMph() else hour.wind_kph;
|
||
const wind_unit = if (options.use_imperial) "mph" else "km/h";
|
||
const arrow = degreeToArrow(hour.wind_deg);
|
||
switch (options.format) {
|
||
.ansi => {
|
||
const color = windColor(hour.wind_kph);
|
||
try cw.print("{s} \x1b[38;5;{d}m{d:.0}\x1b[0m {s}", .{ arrow, color, wind_speed, wind_unit });
|
||
},
|
||
.html => {
|
||
const color = ansiToHex(windColor(hour.wind_kph));
|
||
try cw.print("{s} <span style=\"color:{s}\">{d:.0}</span> {s}", .{ arrow, color, wind_speed, wind_unit });
|
||
},
|
||
.plain_text => {
|
||
try cw.print("{s} {d:.0} {s}", .{ arrow, wind_speed, wind_unit });
|
||
},
|
||
}
|
||
},
|
||
.visibility => {
|
||
if (hour.visibility_km) |_| {
|
||
const visibility = if (options.use_imperial) hour.visiblityMph().? else hour.visibility_km.?;
|
||
const vis_unit = if (options.use_imperial) "mi" else "km";
|
||
try cw.print("{d:.0} {s}", .{ visibility, vis_unit });
|
||
}
|
||
},
|
||
.precipitation => {
|
||
const precip = if (options.use_imperial) hour.precip_mm * 0.0393701 else hour.precip_mm;
|
||
const precip_unit = if (options.use_imperial) "in" else "mm";
|
||
try cw.print("{d:.1} {s} | 0%", .{ precip, precip_unit });
|
||
},
|
||
}
|
||
try cw.flush();
|
||
const buffered = cell_writer.buffered();
|
||
const invisible = countInvisible(buffered, options.format);
|
||
const display_width = art_width + buffered.len - invisible;
|
||
try w.writeAll(buffered);
|
||
try w.splatByteAll(
|
||
' ',
|
||
@max(@as(isize, @intCast(total_width)) - @as(isize, @intCast(display_width)), 0),
|
||
);
|
||
}
|
||
|
||
const DateFormat = enum {
|
||
justified,
|
||
compressed,
|
||
};
|
||
|
||
/// The return value from this function will always be exactly 11 characters long, padded at the
|
||
/// end with any necessary spaces
|
||
fn formatDate(iso_date: []const u8, comptime date_format: DateFormat, date_str_out: []u8) ![]u8 {
|
||
const days = [_][]const u8{ "Sat", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri" };
|
||
const months = [_][]const u8{ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
|
||
|
||
const year = try std.fmt.parseInt(i32, iso_date[0..4], 10);
|
||
const month = try std.fmt.parseInt(u8, iso_date[5..7], 10);
|
||
const day = try std.fmt.parseInt(u8, iso_date[8..10], 10);
|
||
|
||
var y = year;
|
||
var m: i32 = month;
|
||
if (m < 3) {
|
||
m += 12;
|
||
y -= 1;
|
||
}
|
||
const dow = @mod((day + @divFloor((13 * (m + 1)), 5) + y + @divFloor(y, 4) - @divFloor(y, 100) + @divFloor(y, 400)), 7);
|
||
|
||
const day_format = if (date_format == .justified) "{d:>2}" else "{d}";
|
||
const written = try std.fmt.bufPrint(
|
||
date_str_out,
|
||
"{s} " ++ day_format ++ " {s}",
|
||
.{ days[@intCast(dow)], day, months[month - 1] },
|
||
);
|
||
if (written.len < 11)
|
||
@memset(date_str_out[written.len..], ' ');
|
||
return date_str_out[0..11];
|
||
}
|
||
|
||
fn tempColor(temp_c: f32) u8 {
|
||
const temp: i32 = @intFromFloat(@round(temp_c));
|
||
return switch (temp) {
|
||
-15, -14, -13 => 27,
|
||
-12, -11, -10 => 33,
|
||
-9, -8, -7 => 39,
|
||
-6, -5, -4 => 45,
|
||
-3, -2, -1 => 51,
|
||
0, 1 => 50,
|
||
2, 3 => 49,
|
||
4, 5 => 48,
|
||
6, 7 => 47,
|
||
8, 9 => 46,
|
||
10, 11, 12 => 82,
|
||
13, 14, 15 => 118,
|
||
16, 17, 18 => 154,
|
||
19, 20, 21 => 190,
|
||
22, 23, 24 => 226,
|
||
25, 26, 27 => 220,
|
||
28, 29, 30 => 214,
|
||
31, 32, 33 => 208,
|
||
34, 35, 36 => 202,
|
||
else => if (temp > 36) 196 else 21,
|
||
};
|
||
}
|
||
|
||
fn windColor(wind_kph: f32) u8 {
|
||
const wind: i32 = @intFromFloat(@round(wind_kph));
|
||
if (wind <= 3) return 241;
|
||
if (wind <= 6) return 242;
|
||
if (wind <= 9) return 243;
|
||
if (wind <= 12) return 246;
|
||
if (wind <= 15) return 250;
|
||
if (wind <= 19) return 253;
|
||
if (wind <= 23) return 214;
|
||
if (wind <= 27) return 208;
|
||
if (wind <= 31) return 202;
|
||
return 196;
|
||
}
|
||
|
||
fn ansiToHex(code: u8) []const u8 {
|
||
return switch (code) {
|
||
21 => "#0000ff",
|
||
27 => "#005fff",
|
||
33 => "#0087ff",
|
||
39 => "#00afff",
|
||
45 => "#00d7ff",
|
||
46 => "#00ffff",
|
||
47 => "#00ffd7",
|
||
48 => "#00ffaf",
|
||
49 => "#00ff87",
|
||
50 => "#00ff5f",
|
||
51 => "#00ff00",
|
||
82 => "#5fff00",
|
||
118 => "#87ff00",
|
||
154 => "#afff00",
|
||
190 => "#d7ff00",
|
||
196 => "#ff0000",
|
||
202 => "#ff5f00",
|
||
208 => "#ff8700",
|
||
214 => "#ffaf00",
|
||
220 => "#ffd700",
|
||
226 => "#ffff00",
|
||
241 => "#626262",
|
||
242 => "#6c6c6c",
|
||
243 => "#767676",
|
||
246 => "#949494",
|
||
250 => "#bcbcbc",
|
||
253 => "#dadada",
|
||
else => "#ffffff",
|
||
};
|
||
}
|
||
|
||
fn getWeatherArt(code: types.WeatherCode) [5][]const u8 {
|
||
return switch (@intFromEnum(code)) {
|
||
800 => .{ // Clear
|
||
" \\ / ",
|
||
" .-. ",
|
||
" ― ( ) ― ",
|
||
" `-' ",
|
||
" / \\ ",
|
||
},
|
||
801, 802 => .{ // Partly cloudy
|
||
" \\ / ",
|
||
" _ /\"\".-. ",
|
||
" \\_( ). ",
|
||
" /(___(__) ",
|
||
" ",
|
||
},
|
||
803, 804 => .{ // Cloudy
|
||
" ",
|
||
" .--. ",
|
||
" .-( ). ",
|
||
" (___.__)__) ",
|
||
" ",
|
||
},
|
||
300...321, 500...531 => .{ // Drizzle/Rain
|
||
" .-. ",
|
||
" ( ). ",
|
||
" (___(__) ",
|
||
" ʻ ʻ ʻ ʻ ",
|
||
" ʻ ʻ ʻ ʻ ",
|
||
},
|
||
200...232 => .{ // Thunderstorm
|
||
" .-. ",
|
||
" ( ). ",
|
||
" (___(__) ",
|
||
" ⚡ʻ⚡ʻ ",
|
||
" ʻ ʻ ʻ ",
|
||
},
|
||
600...610, 617...622 => .{ // Snow
|
||
" .-. ",
|
||
" ( ). ",
|
||
" (___(__) ",
|
||
" * * * ",
|
||
" * * * ",
|
||
},
|
||
611...616 => .{ // Sleet
|
||
" .-. ",
|
||
" ( ). ",
|
||
" (___(__) ",
|
||
" ʻ * ʻ * ",
|
||
" * ʻ * ʻ ",
|
||
},
|
||
701, 741 => .{ // Fog
|
||
" ",
|
||
" _ - _ - _ - ",
|
||
" _ - _ - _ ",
|
||
" _ - _ - _ - ",
|
||
" ",
|
||
},
|
||
else => .{ // Unknown
|
||
" ",
|
||
" ? ",
|
||
" ¯\\_(ツ)_/¯ ",
|
||
" ",
|
||
" ",
|
||
},
|
||
};
|
||
}
|
||
|
||
test "render with imperial units" {
|
||
const data = types.WeatherData{
|
||
.location = "Chicago",
|
||
.current = .{
|
||
.temp_c = 10.0,
|
||
.feels_like_c = 10.0,
|
||
.condition = "Clear",
|
||
.weather_code = .clear,
|
||
.humidity = 60,
|
||
.wind_kph = 16.0,
|
||
.wind_deg = 0.0,
|
||
.pressure_mb = 1013.0,
|
||
.precip_mm = 0.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{ .use_imperial = true });
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "+50") != null);
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "°F") != null);
|
||
// 10°C should be color 82
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "\x1b[38;5;82m") != null);
|
||
}
|
||
|
||
test "clear weather art" {
|
||
const data = types.WeatherData{
|
||
.location = "Test",
|
||
.current = .{
|
||
.temp_c = 20.0,
|
||
.feels_like_c = 20.0,
|
||
.condition = "Clear",
|
||
.weather_code = .clear,
|
||
.humidity = 50,
|
||
.wind_kph = 10.0,
|
||
.wind_deg = 0.0,
|
||
.pressure_mb = 1013.0,
|
||
.precip_mm = 0.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{});
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "\\ /") != null);
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "( )") != null);
|
||
}
|
||
|
||
test "partly cloudy weather art" {
|
||
const data = types.WeatherData{
|
||
.location = "Test",
|
||
.current = .{
|
||
.temp_c = 18.0,
|
||
.feels_like_c = 18.0,
|
||
.condition = "Partly cloudy",
|
||
.weather_code = .clouds_few,
|
||
.humidity = 55,
|
||
.wind_kph = 12.0,
|
||
.wind_deg = 45.0,
|
||
.pressure_mb = 1013.0,
|
||
.precip_mm = 0.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{});
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "\"\".-.") != null);
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "\\_( )") != null);
|
||
}
|
||
|
||
test "cloudy weather art" {
|
||
const data = types.WeatherData{
|
||
.location = "Test",
|
||
.current = .{
|
||
.temp_c = 15.0,
|
||
.feels_like_c = 15.0,
|
||
.condition = "Cloudy",
|
||
.weather_code = .clouds_overcast,
|
||
.humidity = 70,
|
||
.wind_kph = 15.0,
|
||
.wind_deg = 90.0,
|
||
.pressure_mb = 1010.0,
|
||
.precip_mm = 0.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{});
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, ".--.") != null);
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "(___.__)__)") != null);
|
||
}
|
||
|
||
test "rain weather art" {
|
||
const data = types.WeatherData{
|
||
.location = "Test",
|
||
.current = .{
|
||
.temp_c = 12.0,
|
||
.feels_like_c = 12.0,
|
||
.condition = "Rain",
|
||
.weather_code = .rain_moderate,
|
||
.humidity = 85,
|
||
.wind_kph = 20.0,
|
||
.wind_deg = 135.0,
|
||
.pressure_mb = 1005.0,
|
||
.precip_mm = 5.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{});
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "ʻ ʻ ʻ ʻ") != null);
|
||
}
|
||
|
||
test "thunderstorm weather art" {
|
||
const data = types.WeatherData{
|
||
.location = "Test",
|
||
.current = .{
|
||
.temp_c = 14.0,
|
||
.feels_like_c = 14.0,
|
||
.condition = "Thunderstorm",
|
||
.weather_code = .thunderstorm,
|
||
.humidity = 90,
|
||
.wind_kph = 30.0,
|
||
.wind_deg = 180.0,
|
||
.pressure_mb = 1000.0,
|
||
.precip_mm = 10.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{});
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "⚡") != null);
|
||
}
|
||
|
||
test "snow weather art" {
|
||
const data = types.WeatherData{
|
||
.location = "Test",
|
||
.current = .{
|
||
.temp_c = -2.0,
|
||
.feels_like_c = -2.0,
|
||
.condition = "Snow",
|
||
.weather_code = .snow,
|
||
.humidity = 80,
|
||
.wind_kph = 18.0,
|
||
.wind_deg = 225.0,
|
||
.pressure_mb = 1008.0,
|
||
.precip_mm = 3.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{});
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "* * *") != null);
|
||
}
|
||
|
||
test "sleet weather art" {
|
||
const data = types.WeatherData{
|
||
.location = "Test",
|
||
.current = .{
|
||
.temp_c = 0.0,
|
||
.feels_like_c = 0.0,
|
||
.condition = "Sleet",
|
||
.weather_code = .sleet,
|
||
.humidity = 75,
|
||
.wind_kph = 22.0,
|
||
.wind_deg = 270.0,
|
||
.pressure_mb = 1007.0,
|
||
.precip_mm = 2.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{});
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "ʻ * ʻ *") != null);
|
||
}
|
||
|
||
test "fog weather art" {
|
||
const data = types.WeatherData{
|
||
.location = "Test",
|
||
.current = .{
|
||
.temp_c = 8.0,
|
||
.feels_like_c = 8.0,
|
||
.condition = "Fog",
|
||
.weather_code = .fog,
|
||
.humidity = 95,
|
||
.wind_kph = 5.0,
|
||
.wind_deg = 315.0,
|
||
.pressure_mb = 1012.0,
|
||
.precip_mm = 0.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{});
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "_ - _ - _ -") != null);
|
||
}
|
||
|
||
test "unknown weather code art" {
|
||
const data = types.WeatherData{
|
||
.location = "Test",
|
||
.current = .{
|
||
.temp_c = 16.0,
|
||
.feels_like_c = 16.0,
|
||
.condition = "Unknown",
|
||
.weather_code = .unknown,
|
||
.humidity = 60,
|
||
.wind_kph = 10.0,
|
||
.wind_deg = 0.0,
|
||
.pressure_mb = 1013.0,
|
||
.precip_mm = 0.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const output = try render(std.testing.allocator, data, .{});
|
||
defer std.testing.allocator.free(output);
|
||
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "?") != null);
|
||
try std.testing.expect(std.mem.indexOf(u8, output, "¯\\_(ツ)_/¯") != null);
|
||
}
|
||
|
||
test "temperature matches between ansi and custom format" {
|
||
const custom = @import("custom.zig");
|
||
|
||
const data = types.WeatherData{
|
||
.location = "PDX",
|
||
.current = .{
|
||
.temp_c = 13.1,
|
||
.feels_like_c = 13.1,
|
||
.condition = "Clear",
|
||
.weather_code = .clear,
|
||
.humidity = 60,
|
||
.wind_kph = 10.0,
|
||
.wind_deg = 0.0,
|
||
.pressure_mb = 1013.0,
|
||
.precip_mm = 0.0,
|
||
.visibility_km = null,
|
||
},
|
||
.forecast = &.{},
|
||
.allocator = std.testing.allocator,
|
||
};
|
||
|
||
const ansi_output = try render(std.testing.allocator, data, .{ .use_imperial = true });
|
||
defer std.testing.allocator.free(ansi_output);
|
||
|
||
const custom_output = try custom.render(std.testing.allocator, data, "%t", true);
|
||
defer std.testing.allocator.free(custom_output);
|
||
|
||
// ANSI rounds to integer, custom shows decimal
|
||
try std.testing.expect(std.mem.indexOf(u8, ansi_output, "+56") != null);
|
||
try std.testing.expect(std.mem.indexOf(u8, custom_output, "55.6°F") != null);
|
||
}
|
||
|
||
test "tempColor returns correct colors for temperature ranges" {
|
||
// Very cold
|
||
try std.testing.expectEqual(@as(u8, 27), tempColor(-15));
|
||
try std.testing.expectEqual(@as(u8, 27), tempColor(-13));
|
||
try std.testing.expectEqual(@as(u8, 33), tempColor(-12));
|
||
try std.testing.expectEqual(@as(u8, 33), tempColor(-10));
|
||
|
||
// Cold
|
||
try std.testing.expectEqual(@as(u8, 39), tempColor(-9));
|
||
try std.testing.expectEqual(@as(u8, 45), tempColor(-6));
|
||
try std.testing.expectEqual(@as(u8, 51), tempColor(-3));
|
||
|
||
// Cool
|
||
try std.testing.expectEqual(@as(u8, 50), tempColor(0));
|
||
try std.testing.expectEqual(@as(u8, 49), tempColor(2));
|
||
try std.testing.expectEqual(@as(u8, 48), tempColor(4));
|
||
try std.testing.expectEqual(@as(u8, 46), tempColor(8));
|
||
|
||
// Mild
|
||
try std.testing.expectEqual(@as(u8, 82), tempColor(10));
|
||
try std.testing.expectEqual(@as(u8, 118), tempColor(13));
|
||
try std.testing.expectEqual(@as(u8, 118), tempColor(15));
|
||
|
||
// Warm
|
||
try std.testing.expectEqual(@as(u8, 154), tempColor(16));
|
||
try std.testing.expectEqual(@as(u8, 190), tempColor(20));
|
||
try std.testing.expectEqual(@as(u8, 226), tempColor(23));
|
||
try std.testing.expectEqual(@as(u8, 220), tempColor(26));
|
||
|
||
// Hot
|
||
try std.testing.expectEqual(@as(u8, 214), tempColor(29));
|
||
try std.testing.expectEqual(@as(u8, 208), tempColor(32));
|
||
try std.testing.expectEqual(@as(u8, 202), tempColor(35));
|
||
|
||
// Very hot
|
||
try std.testing.expectEqual(@as(u8, 196), tempColor(37));
|
||
try std.testing.expectEqual(@as(u8, 196), tempColor(50));
|
||
|
||
// Very cold (below range)
|
||
try std.testing.expectEqual(@as(u8, 21), tempColor(-20));
|
||
}
|
||
|
||
test "windColor returns correct colors for wind speed ranges" {
|
||
// Calm
|
||
try std.testing.expectEqual(@as(u8, 241), windColor(0));
|
||
try std.testing.expectEqual(@as(u8, 241), windColor(3));
|
||
|
||
// Light breeze
|
||
try std.testing.expectEqual(@as(u8, 242), windColor(4));
|
||
try std.testing.expectEqual(@as(u8, 242), windColor(6));
|
||
try std.testing.expectEqual(@as(u8, 243), windColor(7));
|
||
try std.testing.expectEqual(@as(u8, 243), windColor(9));
|
||
|
||
// Moderate
|
||
try std.testing.expectEqual(@as(u8, 246), windColor(10));
|
||
try std.testing.expectEqual(@as(u8, 246), windColor(12));
|
||
try std.testing.expectEqual(@as(u8, 250), windColor(13));
|
||
try std.testing.expectEqual(@as(u8, 250), windColor(15));
|
||
try std.testing.expectEqual(@as(u8, 253), windColor(16));
|
||
try std.testing.expectEqual(@as(u8, 253), windColor(19));
|
||
|
||
// Fresh
|
||
try std.testing.expectEqual(@as(u8, 214), windColor(20));
|
||
try std.testing.expectEqual(@as(u8, 214), windColor(23));
|
||
try std.testing.expectEqual(@as(u8, 208), windColor(24));
|
||
try std.testing.expectEqual(@as(u8, 208), windColor(27));
|
||
|
||
// Strong
|
||
try std.testing.expectEqual(@as(u8, 202), windColor(28));
|
||
try std.testing.expectEqual(@as(u8, 202), windColor(31));
|
||
try std.testing.expectEqual(@as(u8, 196), windColor(32));
|
||
try std.testing.expectEqual(@as(u8, 196), windColor(50));
|
||
}
|
||
test "plain text format - MetNo real data" {
|
||
const allocator = std.testing.allocator;
|
||
const MetNo = @import("../weather/MetNo.zig");
|
||
|
||
const json_data = @embedFile("../tests/metno_test_data.json");
|
||
|
||
const weather_data = try MetNo.parse(undefined, allocator, json_data);
|
||
defer weather_data.deinit();
|
||
|
||
const output = try render(allocator, weather_data, .{ .format = .plain_text, .days = 3 });
|
||
defer allocator.free(output);
|
||
|
||
const expected =
|
||
\\Weather report: 47.6038,-122.3301
|
||
\\
|
||
\\ .-. Light rain
|
||
\\ ( ). +7(+7) °C
|
||
\\ (___(__) ← 6 km/h
|
||
\\ ʻ ʻ ʻ ʻ
|
||
\\ ʻ ʻ ʻ ʻ 0.0 mm
|
||
\\
|
||
\\
|
||
\\Fri 2 Jan
|
||
\\ .-. Rain
|
||
\\ ( ). 7°C / 7°C
|
||
\\ (___(__)
|
||
\\ ʻ ʻ ʻ ʻ
|
||
\\ ʻ ʻ ʻ ʻ
|
||
\\ ┌─────────────┐
|
||
\\┌──────────────────────────────┬───────────────────────┤ Sat 3 Jan ├───────────────────────┬──────────────────────────────┐
|
||
\\│ Morning │ Noon └──────┬──────┘ Evening │ Night │
|
||
\\├──────────────────────────────┼──────────────────────────────┼──────────────────────────────┼──────────────────────────────┤
|
||
\\│ .-. Rain │ Cloudy │ .-. Heavy rain │ \ / Partly cloudy │
|
||
\\│ ( ). +7(+7) °C │ .--. +6(+6) °C │ ( ). +7(+7) °C │ _ /"".-. +8(+8) °C │
|
||
\\│ (___(__) ↖ 5 km/h │ .-( ). ↓ 9 km/h │ (___(__) ↖ 14 km/h │ \_( ). ↑ 12 km/h │
|
||
\\│ ʻ ʻ ʻ ʻ │ (___.__)__) │ ʻ ʻ ʻ ʻ │ /(___(__) │
|
||
\\│ ʻ ʻ ʻ ʻ 0.3 mm | 0% │ 0.0 mm | 0% │ ʻ ʻ ʻ ʻ 1.2 mm | 0% │ 0.0 mm | 0% │
|
||
\\└──────────────────────────────┴──────────────────────────────┴──────────────────────────────┴──────────────────────────────┘
|
||
\\ ┌─────────────┐
|
||
\\┌──────────────────────────────┬───────────────────────┤ Sun 4 Jan ├───────────────────────┬──────────────────────────────┐
|
||
\\│ Morning │ Noon └──────┬──────┘ Evening │ Night │
|
||
\\├──────────────────────────────┼──────────────────────────────┼──────────────────────────────┼──────────────────────────────┤
|
||
\\│ Cloudy │ Cloudy │ Cloudy │ .-. Light rain │
|
||
\\│ .--. +10(+10) °C │ .--. +8(+8) °C │ .--. +10(+10) °C │ ( ). +9(+9) °C │
|
||
\\│ .-( ). ↙ 7 km/h │ .-( ). ↑ 14 km/h │ .-( ). ↑ 31 km/h │ (___(__) ↑ 24 km/h │
|
||
\\│ (___.__)__) │ (___.__)__) │ (___.__)__) │ ʻ ʻ ʻ ʻ │
|
||
\\│ 0.0 mm | 0% │ 0.0 mm | 0% │ 0.0 mm | 0% │ ʻ ʻ ʻ ʻ 0.2 mm | 0% │
|
||
\\└──────────────────────────────┴──────────────────────────────┴──────────────────────────────┴──────────────────────────────┘
|
||
\\
|
||
;
|
||
|
||
try std.testing.expectEqualStrings(expected, output);
|
||
}
|
||
test "ansi format - MetNo real data - phoenix" {
|
||
const allocator = std.testing.allocator;
|
||
const MetNo = @import("../weather/MetNo.zig");
|
||
|
||
const json_data = @embedFile("../tests/metno-phoenix.json");
|
||
|
||
const weather_data = try MetNo.parse(undefined, allocator, json_data);
|
||
defer weather_data.deinit();
|
||
|
||
const output = try render(allocator, weather_data, .{ .format = .ansi, .days = 3, .use_imperial = true });
|
||
defer allocator.free(output);
|
||
|
||
// const file = try std.fs.cwd().createFile("/tmp/formatted_output.txt", .{});
|
||
// defer file.close();
|
||
// try file.writeAll(output);
|
||
|
||
const expected = @embedFile("../tests/metno-phoenix-tmp.ansi");
|
||
|
||
try std.testing.expectEqualStrings(expected, output);
|
||
}
|
||
|
||
test "countInvisible - plain text with UTF-8" {
|
||
const testing = std.testing;
|
||
try testing.expectEqual(0, countInvisible("hello", .plain_text));
|
||
try testing.expectEqual(1, countInvisible("°C", .plain_text)); // ° is 2 bytes
|
||
try testing.expectEqual(2, countInvisible("↑", .plain_text)); // ↑ is 3 bytes
|
||
try testing.expectEqual(3, countInvisible("°C ↑", .plain_text));
|
||
}
|
||
|
||
test "countInvisible - ANSI escape sequences" {
|
||
const testing = std.testing;
|
||
try testing.expectEqual(0, countInvisible("hello", .ansi));
|
||
try testing.expectEqual(14, countInvisible("\x1b[38;5;82mhello\x1b[0m", .ansi));
|
||
try testing.expectEqual(1, countInvisible("°C", .ansi)); // UTF-8 still counted
|
||
try testing.expectEqual(15, countInvisible("\x1b[38;5;82m°C\x1b[0m", .ansi));
|
||
}
|
||
|
||
test "countInvisible - HTML tags" {
|
||
const testing = std.testing;
|
||
try testing.expectEqual(0, countInvisible("hello", .html));
|
||
try testing.expectEqual(25, countInvisible("<span class=\"c82\">hello</span>", .html));
|
||
try testing.expectEqual(1, countInvisible("°C", .html)); // UTF-8 still counted
|
||
}
|
||
|
||
test "countInvisible - ansi full string" {
|
||
const str = "\x1b[38;5;250m .--. \x1b[0m \x1b[38;5;154m+61(+61)\x1b[0m °F ";
|
||
try std.testing.expectEqual(28, str.len - countInvisible(str, .ansi));
|
||
}
|
||
|
||
test "countInvisible - ansi formatted" {
|
||
const str = "\x1b[38;5;154m+61(+61)\x1b[0m °F";
|
||
try std.testing.expectEqual(11, str.len - countInvisible(str, .ansi));
|
||
}
|