this repo has no description
examples: refactor fuzzy.zig
authored by
Danylo Kondratiev
and committed by
Tim Culverhouse
fa42ea03
fa6f3247
+68
-55
+68
-55
examples/fuzzy.zig
+68
-55
examples/fuzzy.zig
···
8
8
filtered: std.ArrayList(vxfw.RichText),
9
9
list_view: vxfw.ListView,
10
10
text_field: vxfw.TextField,
11
+
12
+
/// Used for filtered RichText Spans and result
13
+
arena: std.heap.ArenaAllocator,
14
+
filtered: std.ArrayList(vxfw.RichText),
11
15
result: []const u8,
12
16
13
-
/// Used for filtered RichText Spans
14
-
arena: std.heap.ArenaAllocator,
17
+
pub fn init(gpa: std.mem.Allocator) !*Model {
18
+
const model = try gpa.create(Model);
19
+
errdefer gpa.destroy(model);
20
+
21
+
model.* = .{
22
+
.list = .empty,
23
+
.filtered = .empty,
24
+
.list_view = .{
25
+
.children = .{
26
+
.builder = .{
27
+
.userdata = model,
28
+
.buildFn = Model.widgetBuilder,
29
+
},
30
+
},
31
+
},
32
+
.text_field = .{
33
+
.buf = vxfw.TextField.Buffer.init(gpa),
34
+
.userdata = model,
35
+
.onChange = Model.onChange,
36
+
.onSubmit = Model.onSubmit,
37
+
},
38
+
.result = "",
39
+
.arena = std.heap.ArenaAllocator.init(gpa),
40
+
};
41
+
42
+
return model;
43
+
}
44
+
45
+
pub fn deinit(self: *Model, gpa: std.mem.Allocator) void {
46
+
self.arena.deinit();
47
+
self.text_field.deinit();
48
+
self.list.deinit(gpa);
49
+
gpa.destroy(self);
50
+
}
15
51
16
52
pub fn widget(self: *Model) vxfw.Widget {
17
53
return .{
···
26
62
switch (event) {
27
63
.init => {
28
64
// Initialize the filtered list
29
-
const allocator = self.arena.allocator();
65
+
const arena = self.arena.allocator();
30
66
for (self.list.items) |line| {
31
-
var spans = std.ArrayList(vxfw.RichText.TextSpan){};
67
+
var spans = std.ArrayList(vxfw.RichText.TextSpan).empty;
32
68
const span: vxfw.RichText.TextSpan = .{ .text = line.text };
33
-
try spans.append(allocator, span);
34
-
try self.filtered.append(allocator, .{ .text = spans.items });
69
+
try spans.append(arena, span);
70
+
try self.filtered.append(arena, .{ .text = spans.items });
35
71
}
36
72
37
73
return ctx.requestFocus(self.text_field.widget());
···
100
136
fn onChange(maybe_ptr: ?*anyopaque, _: *vxfw.EventContext, str: []const u8) anyerror!void {
101
137
const ptr = maybe_ptr orelse return;
102
138
const self: *Model = @ptrCast(@alignCast(ptr));
103
-
const allocator = self.arena.allocator();
104
-
self.filtered.clearAndFree(allocator);
139
+
const arena = self.arena.allocator();
140
+
self.filtered.clearAndFree(arena);
105
141
_ = self.arena.reset(.free_all);
106
142
107
143
const hasUpper = for (str) |b| {
···
115
151
const tgt = if (hasUpper)
116
152
item.text
117
153
else
118
-
try toLower(allocator, item.text);
154
+
try toLower(arena, item.text);
119
155
120
-
var spans = std.ArrayList(vxfw.RichText.TextSpan){};
156
+
var spans = std.ArrayList(vxfw.RichText.TextSpan).empty;
121
157
var i: usize = 0;
122
158
var iter = vaxis.unicode.graphemeIterator(str);
123
159
while (iter.next()) |g| {
···
127
163
.text = item.text[idx .. idx + g.len],
128
164
.style = .{ .fg = .{ .index = 4 }, .reverse = true },
129
165
};
130
-
try spans.append(allocator, up_to_here);
131
-
try spans.append(allocator, match);
166
+
try spans.append(arena, up_to_here);
167
+
try spans.append(arena, match);
132
168
i = idx + g.len;
133
169
} else continue :outer;
134
170
}
135
171
const up_to_here: vxfw.RichText.TextSpan = .{ .text = item.text[i..] };
136
-
try spans.append(allocator, up_to_here);
137
-
try self.filtered.append(allocator, .{ .text = spans.items });
172
+
try spans.append(arena, up_to_here);
173
+
try self.filtered.append(arena, .{ .text = spans.items });
138
174
}
139
175
self.list_view.scroll.top = 0;
140
176
self.list_view.scroll.offset = 0;
···
146
182
const self: *Model = @ptrCast(@alignCast(ptr));
147
183
if (self.list_view.cursor < self.filtered.items.len) {
148
184
const selected = self.filtered.items[self.list_view.cursor];
149
-
const allocator = self.arena.allocator();
150
-
var result = std.ArrayList(u8){};
185
+
const arena = self.arena.allocator();
186
+
var result = std.ArrayList(u8).empty;
151
187
for (selected.text) |span| {
152
-
try result.appendSlice(allocator, span.text);
188
+
try result.appendSlice(arena, span.text);
153
189
}
154
190
self.result = result.items;
155
191
}
···
157
193
}
158
194
};
159
195
160
-
fn toLower(allocator: std.mem.Allocator, src: []const u8) std.mem.Allocator.Error![]const u8 {
161
-
const lower = try allocator.alloc(u8, src.len);
196
+
fn toLower(arena: std.mem.Allocator, src: []const u8) std.mem.Allocator.Error![]const u8 {
197
+
const lower = try arena.alloc(u8, src.len);
162
198
for (src, 0..) |b, i| {
163
199
lower[i] = std.ascii.toLower(b);
164
200
}
···
166
202
}
167
203
168
204
pub fn main() !void {
169
-
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
170
-
defer _ = gpa.deinit();
205
+
var debug_allocator = std.heap.GeneralPurposeAllocator(.{}){};
206
+
defer _ = debug_allocator.deinit();
171
207
172
-
const allocator = gpa.allocator();
208
+
const gpa = debug_allocator.allocator();
173
209
174
-
var app = try vxfw.App.init(allocator);
210
+
var app = try vxfw.App.init(gpa);
175
211
errdefer app.deinit();
176
212
177
-
const model = try allocator.create(Model);
178
-
defer allocator.destroy(model);
179
-
model.* = .{
180
-
.list = std.ArrayList(vxfw.Text){},
181
-
.filtered = std.ArrayList(vxfw.RichText){},
182
-
.list_view = .{
183
-
.children = .{
184
-
.builder = .{
185
-
.userdata = model,
186
-
.buildFn = Model.widgetBuilder,
187
-
},
188
-
},
189
-
},
190
-
.text_field = .{
191
-
.buf = vxfw.TextField.Buffer.init(allocator),
192
-
.userdata = model,
193
-
.onChange = Model.onChange,
194
-
.onSubmit = Model.onSubmit,
195
-
},
196
-
.result = "",
197
-
.arena = std.heap.ArenaAllocator.init(allocator),
198
-
};
199
-
defer model.text_field.deinit();
200
-
defer model.list.deinit(allocator);
201
-
defer model.arena.deinit();
213
+
const model = try Model.init(gpa);
214
+
defer model.deinit(gpa);
202
215
203
216
// Run the command
204
-
var fd = std.process.Child.init(&.{"fd"}, allocator);
217
+
var fd = std.process.Child.init(&.{"fd"}, gpa);
205
218
fd.stdout_behavior = .Pipe;
206
219
fd.stderr_behavior = .Pipe;
207
-
var stdout = std.ArrayList(u8){};
208
-
var stderr = std.ArrayList(u8){};
209
-
defer stdout.deinit(allocator);
210
-
defer stderr.deinit(allocator);
220
+
var stdout = std.ArrayList(u8).empty;
221
+
var stderr = std.ArrayList(u8).empty;
222
+
defer stdout.deinit(gpa);
223
+
defer stderr.deinit(gpa);
211
224
try fd.spawn();
212
-
try fd.collectOutput(allocator, &stdout, &stderr, 10_000_000);
225
+
try fd.collectOutput(gpa, &stdout, &stderr, 10_000_000);
213
226
_ = try fd.wait();
214
227
215
228
var iter = std.mem.splitScalar(u8, stdout.items, '\n');
216
229
while (iter.next()) |line| {
217
230
if (line.len == 0) continue;
218
-
try model.list.append(allocator, .{ .text = line });
231
+
try model.list.append(gpa, .{ .text = line });
219
232
}
220
233
221
234
try app.run(model.widget(), .{});